1130 lines
42 KiB
Python
1130 lines
42 KiB
Python
# Copyright (C) 2011-2024 RhodeCode GmbH
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License, version 3
|
|
# (only), as published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# This program is dual-licensed. If you wish to learn more about the
|
|
# RhodeCode Enterprise Edition, including its added features, Support services,
|
|
# and proprietary license terms, please see https://rhodecode.com/licenses/
|
|
|
|
|
|
import logging
|
|
|
|
from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
|
|
from rhodecode.api.utils import (
|
|
has_superadmin_permission,
|
|
Optional,
|
|
OAttr,
|
|
get_repo_or_error,
|
|
get_pull_request_or_error,
|
|
get_commit_or_error,
|
|
get_user_or_error,
|
|
validate_repo_permissions,
|
|
resolve_ref_or_error,
|
|
validate_set_owner_permissions,
|
|
)
|
|
from rhodecode.lib import channelstream
|
|
from rhodecode.lib.auth import HasRepoPermissionAnyApi
|
|
from rhodecode.lib.base import vcs_operation_context
|
|
from rhodecode.lib.utils2 import str2bool
|
|
from rhodecode.lib.vcs.backends.base import unicode_to_reference
|
|
from rhodecode.model.changeset_status import ChangesetStatusModel
|
|
from rhodecode.model.comment import CommentsModel
|
|
from rhodecode.model.db import (
|
|
Session,
|
|
ChangesetStatus,
|
|
ChangesetComment,
|
|
PullRequest,
|
|
PullRequestReviewers,
|
|
false,
|
|
true,
|
|
)
|
|
from rhodecode.model.pull_request import PullRequestModel, MergeCheck
|
|
from rhodecode.model.settings import SettingsModel
|
|
from rhodecode.model.validation_schema import Invalid
|
|
from rhodecode.model.validation_schema.schemas.reviewer_schema import ReviewerListSchema
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
@jsonrpc_method()
|
|
def get_pull_request(request, apiuser, pullrequestid, repoid=Optional(None), merge_state=Optional(False)):
|
|
"""
|
|
Get a pull request based on the given ID.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional, repository name or repository ID from where
|
|
the pull request was opened.
|
|
:type repoid: str or int
|
|
:param pullrequestid: ID of the requested pull request.
|
|
:type pullrequestid: int
|
|
:param merge_state: Optional calculate merge state for each repository.
|
|
This could result in longer time to fetch the data
|
|
:type merge_state: bool
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
"id": <id_given_in_input>,
|
|
"result":
|
|
{
|
|
"pull_request_id": "<pull_request_id>",
|
|
"url": "<url>",
|
|
"title": "<title>",
|
|
"description": "<description>",
|
|
"status" : "<status>",
|
|
"created_on": "<date_time_created>",
|
|
"updated_on": "<date_time_updated>",
|
|
"versions": "<number_or_versions_of_pr>",
|
|
"commit_ids": [
|
|
...
|
|
"<commit_id>",
|
|
"<commit_id>",
|
|
...
|
|
],
|
|
"review_status": "<review_status>",
|
|
"mergeable": {
|
|
"status": "<bool>",
|
|
"message": "<message>",
|
|
},
|
|
"source": {
|
|
"clone_url": "<clone_url>",
|
|
"repository": "<repository_name>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"target": {
|
|
"clone_url": "<clone_url>",
|
|
"repository": "<repository_name>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"merge": {
|
|
"clone_url": "<clone_url>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"author": <user_obj>,
|
|
"reviewers": [
|
|
...
|
|
{
|
|
"user": "<user_obj>",
|
|
"review_status": "<review_status>",
|
|
}
|
|
...
|
|
]
|
|
},
|
|
"error": null
|
|
"""
|
|
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
if not PullRequestModel().check_user_read(pull_request, apiuser, api=True):
|
|
raise JSONRPCError(f"repository `{repoid}` or pull request `{pullrequestid}` does not exist")
|
|
|
|
# NOTE(marcink): only calculate and return merge state if the pr state is 'created'
|
|
# otherwise we can lock the repo on calculation of merge state while update/merge
|
|
# is happening.
|
|
pr_created = pull_request.pull_request_state == pull_request.STATE_CREATED
|
|
merge_state = Optional.extract(merge_state, binary=True) and pr_created
|
|
data = pull_request.get_api_data(with_merge_state=merge_state)
|
|
return data
|
|
|
|
|
|
@jsonrpc_method()
|
|
def get_pull_requests(request, apiuser, repoid, status=Optional("new"), merge_state=Optional(False)):
|
|
"""
|
|
Get all pull requests from the repository specified in `repoid`.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional repository name or repository ID.
|
|
:type repoid: str or int
|
|
:param status: Only return pull requests with the specified status.
|
|
Valid options are.
|
|
* ``new`` (default)
|
|
* ``open``
|
|
* ``closed``
|
|
:type status: str
|
|
:param merge_state: Optional calculate merge state for each repository.
|
|
This could result in longer time to fetch the data
|
|
:type merge_state: bool
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
"id": <id_given_in_input>,
|
|
"result":
|
|
[
|
|
...
|
|
{
|
|
"pull_request_id": "<pull_request_id>",
|
|
"url": "<url>",
|
|
"title" : "<title>",
|
|
"description": "<description>",
|
|
"status": "<status>",
|
|
"created_on": "<date_time_created>",
|
|
"updated_on": "<date_time_updated>",
|
|
"commit_ids": [
|
|
...
|
|
"<commit_id>",
|
|
"<commit_id>",
|
|
...
|
|
],
|
|
"review_status": "<review_status>",
|
|
"mergeable": {
|
|
"status": "<bool>",
|
|
"message: "<message>",
|
|
},
|
|
"source": {
|
|
"clone_url": "<clone_url>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"target": {
|
|
"clone_url": "<clone_url>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"merge": {
|
|
"clone_url": "<clone_url>",
|
|
"reference":
|
|
{
|
|
"name": "<name>",
|
|
"type": "<type>",
|
|
"commit_id": "<commit_id>",
|
|
}
|
|
},
|
|
"author": <user_obj>,
|
|
"reviewers": [
|
|
...
|
|
{
|
|
"user": "<user_obj>",
|
|
"review_status": "<review_status>",
|
|
}
|
|
...
|
|
]
|
|
}
|
|
...
|
|
],
|
|
"error": null
|
|
|
|
"""
|
|
repo = get_repo_or_error(repoid)
|
|
if not has_superadmin_permission(apiuser):
|
|
_perms = (
|
|
"repository.admin",
|
|
"repository.write",
|
|
"repository.read",
|
|
)
|
|
validate_repo_permissions(apiuser, repoid, repo, _perms)
|
|
|
|
status = Optional.extract(status)
|
|
merge_state = Optional.extract(merge_state, binary=True)
|
|
pull_requests = PullRequestModel().get_all(repo, statuses=[status], order_by="id", order_dir="desc")
|
|
data = [pr.get_api_data(with_merge_state=merge_state) for pr in pull_requests]
|
|
return data
|
|
|
|
|
|
@jsonrpc_method()
|
|
def merge_pull_request(request, apiuser, pullrequestid, repoid=Optional(None), userid=Optional(OAttr("apiuser"))):
|
|
"""
|
|
Merge the pull request specified by `pullrequestid` into its target
|
|
repository.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional, repository name or repository ID of the
|
|
target repository to which the |pr| is to be merged.
|
|
:type repoid: str or int
|
|
:param pullrequestid: ID of the pull request which shall be merged.
|
|
:type pullrequestid: int
|
|
:param userid: Merge the pull request as this user.
|
|
:type userid: Optional(str or int)
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
"id": <id_given_in_input>,
|
|
"result": {
|
|
"executed": "<bool>",
|
|
"failure_reason": "<int>",
|
|
"merge_status_message": "<str>",
|
|
"merge_commit_id": "<merge_commit_id>",
|
|
"possible": "<bool>",
|
|
"merge_ref": {
|
|
"commit_id": "<commit_id>",
|
|
"type": "<type>",
|
|
"name": "<name>"
|
|
}
|
|
},
|
|
"error": null
|
|
"""
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
auth_user = apiuser
|
|
if not isinstance(userid, Optional):
|
|
# super-admin can impersonate other users
|
|
if has_superadmin_permission(apiuser):
|
|
apiuser = get_user_or_error(userid)
|
|
auth_user = apiuser.AuthUser()
|
|
else:
|
|
raise JSONRPCError("Provided userid is not the same the user calling this function")
|
|
|
|
if pull_request.pull_request_state != PullRequest.STATE_CREATED:
|
|
raise JSONRPCError(
|
|
f"Operation forbidden because pull request is in state {pull_request.pull_request_state}, only state {PullRequest.STATE_CREATED} is allowed."
|
|
)
|
|
|
|
with pull_request.set_state(PullRequest.STATE_UPDATING):
|
|
check = MergeCheck.validate(pull_request, auth_user=auth_user, translator=request.translate)
|
|
merge_possible = not check.failed
|
|
|
|
if not merge_possible:
|
|
error_messages = []
|
|
for err_type, error_msg in check.errors:
|
|
error_msg = request.translate(error_msg)
|
|
error_messages.append(error_msg)
|
|
|
|
reasons = ",".join(error_messages)
|
|
raise JSONRPCError(f"merge not possible for following reasons: {reasons}")
|
|
|
|
target_repo = pull_request.target_repo
|
|
extras = vcs_operation_context(
|
|
request.environ,
|
|
repo_name=target_repo.repo_name,
|
|
username=auth_user.username,
|
|
action="push",
|
|
scm=target_repo.repo_type,
|
|
)
|
|
with pull_request.set_state(PullRequest.STATE_UPDATING):
|
|
merge_response = PullRequestModel().merge_repo(pull_request, apiuser, extras=extras)
|
|
if merge_response.executed:
|
|
PullRequestModel().close_pull_request(pull_request.pull_request_id, auth_user)
|
|
|
|
Session().commit()
|
|
|
|
# In previous versions the merge response directly contained the merge
|
|
# commit id. It is now contained in the merge reference object. To be
|
|
# backwards compatible we have to extract it again.
|
|
merge_response = merge_response.asdict()
|
|
merge_response["merge_commit_id"] = merge_response["merge_ref"].commit_id
|
|
|
|
return merge_response
|
|
|
|
|
|
@jsonrpc_method()
|
|
def get_pull_request_comments(request, apiuser, pullrequestid, repoid=Optional(None)):
|
|
"""
|
|
Get all comments of pull request specified with the `pullrequestid`
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional repository name or repository ID.
|
|
:type repoid: str or int
|
|
:param pullrequestid: The pull request ID.
|
|
:type pullrequestid: int
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
id : <id_given_in_input>
|
|
result : [
|
|
{
|
|
"comment_author": {
|
|
"active": true,
|
|
"full_name_or_username": "Tom Gore",
|
|
"username": "admin"
|
|
},
|
|
"comment_created_on": "2017-01-02T18:43:45.533",
|
|
"comment_f_path": null,
|
|
"comment_id": 25,
|
|
"comment_lineno": null,
|
|
"comment_status": {
|
|
"status": "under_review",
|
|
"status_lbl": "Under Review"
|
|
},
|
|
"comment_text": "Example text",
|
|
"comment_type": null,
|
|
"comment_last_version: 0,
|
|
"pull_request_version": null,
|
|
"comment_commit_id": None,
|
|
"comment_pull_request_id": <pull_request_id>
|
|
}
|
|
],
|
|
error : null
|
|
"""
|
|
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
if not PullRequestModel().check_user_read(pull_request, apiuser, api=True):
|
|
raise JSONRPCError(f"repository `{repoid}` or pull request `{pullrequestid}` does not exist")
|
|
|
|
(pull_request_latest, pull_request_at_ver, pull_request_display_obj, at_version) = (
|
|
PullRequestModel().get_pr_version(pull_request.pull_request_id, version=None)
|
|
)
|
|
|
|
versions = pull_request_display_obj.versions()
|
|
ver_map = {ver.pull_request_version_id: cnt for cnt, ver in enumerate(versions, 1)}
|
|
|
|
# GENERAL COMMENTS with versions #
|
|
q = CommentsModel()._all_general_comments_of_pull_request(pull_request)
|
|
q = q.order_by(ChangesetComment.comment_id.asc())
|
|
q = q.filter(ChangesetComment.draft == false())
|
|
general_comments = q.all()
|
|
|
|
# INLINE COMMENTS with versions #
|
|
q = CommentsModel()._all_inline_comments_of_pull_request(pull_request)
|
|
q = q.order_by(ChangesetComment.comment_id.asc())
|
|
q = q.filter(ChangesetComment.draft == false())
|
|
inline_comments = q.all()
|
|
|
|
# INLINE DRAFT COMMENTS with versions #
|
|
q = CommentsModel()._all_inline_comments_of_pull_request(pull_request)
|
|
q = q.order_by(ChangesetComment.comment_id.asc())
|
|
q = q.filter(ChangesetComment.user_id == apiuser.user_id)
|
|
q = q.filter(ChangesetComment.draft == true())
|
|
inline_draft_comments = q.all()
|
|
log.error(q)
|
|
|
|
data = []
|
|
for comment in inline_draft_comments + inline_comments + general_comments:
|
|
full_data = comment.get_api_data()
|
|
pr_version_id = None
|
|
if comment.pull_request_version_id:
|
|
pr_version_id = f"v{ver_map[comment.pull_request_version_id]}"
|
|
|
|
# sanitize some entries
|
|
|
|
full_data["pull_request_version"] = pr_version_id
|
|
full_data["comment_author"] = {
|
|
"username": full_data["comment_author"].username,
|
|
"full_name_or_username": full_data["comment_author"].full_name_or_username,
|
|
"active": full_data["comment_author"].active,
|
|
}
|
|
|
|
if full_data["comment_status"]:
|
|
full_data["comment_status"] = {
|
|
"status": full_data["comment_status"][0].status,
|
|
"status_lbl": full_data["comment_status"][0].status_lbl,
|
|
}
|
|
else:
|
|
full_data["comment_status"] = {}
|
|
|
|
data.append(full_data)
|
|
return data
|
|
|
|
|
|
@jsonrpc_method()
|
|
def comment_pull_request(
|
|
request,
|
|
apiuser,
|
|
pullrequestid,
|
|
repoid=Optional(None),
|
|
message=Optional(None),
|
|
commit_id=Optional(None),
|
|
status=Optional(None),
|
|
comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
|
|
resolves_comment_id=Optional(None),
|
|
extra_recipients=Optional([]),
|
|
userid=Optional(OAttr("apiuser")),
|
|
send_email=Optional(True),
|
|
):
|
|
"""
|
|
Comment on the pull request specified with the `pullrequestid`,
|
|
in the |repo| specified by the `repoid`, and optionally change the
|
|
review status.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional repository name or repository ID.
|
|
:type repoid: str or int
|
|
:param pullrequestid: The pull request ID.
|
|
:type pullrequestid: int
|
|
:param commit_id: Specify the commit_id for which to set a comment. If
|
|
given commit_id is different than latest in the PR status
|
|
change won't be performed.
|
|
:type commit_id: str
|
|
:param message: The text content of the comment.
|
|
:type message: str
|
|
:param status: (**Optional**) Set the approval status of the pull
|
|
request. One of: 'not_reviewed', 'approved', 'rejected',
|
|
'under_review'
|
|
:type status: str
|
|
:param comment_type: Comment type, one of: 'note', 'todo'
|
|
:type comment_type: Optional(str), default: 'note'
|
|
:param resolves_comment_id: id of comment which this one will resolve
|
|
:type resolves_comment_id: Optional(int)
|
|
:param extra_recipients: list of user ids or usernames to add
|
|
notifications for this comment. Acts like a CC for notification
|
|
:type extra_recipients: Optional(list)
|
|
:param userid: Comment on the pull request as this user
|
|
:type userid: Optional(str or int)
|
|
:param send_email: Define if this comment should also send email notification
|
|
:type send_email: Optional(bool)
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
id : <id_given_in_input>
|
|
result : {
|
|
"pull_request_id": "<Integer>",
|
|
"comment_id": "<Integer>",
|
|
"status": {"given": <given_status>,
|
|
"was_changed": <bool status_was_actually_changed> },
|
|
},
|
|
error : null
|
|
"""
|
|
_ = request.translate
|
|
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
db_repo_name = repo.repo_name
|
|
|
|
auth_user = apiuser
|
|
if isinstance(userid, Optional):
|
|
userid = apiuser.user_id
|
|
else:
|
|
# super-admin can impersonate other users
|
|
if has_superadmin_permission(apiuser):
|
|
apiuser = get_user_or_error(userid)
|
|
userid = apiuser.user_id
|
|
auth_user = apiuser.AuthUser()
|
|
else:
|
|
raise JSONRPCError("Provided userid is not the same the user calling this function")
|
|
|
|
if pull_request.is_closed():
|
|
raise JSONRPCError(f"pull request `{pullrequestid}` comment failed, pull request is closed")
|
|
|
|
if not PullRequestModel().check_user_read(pull_request, apiuser, api=True):
|
|
raise JSONRPCError(f"repository `{repoid}` does not exist")
|
|
|
|
user = get_user_or_error(userid)
|
|
message = Optional.extract(message)
|
|
status = Optional.extract(status)
|
|
commit_id = Optional.extract(commit_id)
|
|
comment_type = Optional.extract(comment_type)
|
|
resolves_comment_id = Optional.extract(resolves_comment_id)
|
|
extra_recipients = Optional.extract(extra_recipients)
|
|
send_email = Optional.extract(send_email, binary=True)
|
|
|
|
if not message and not status:
|
|
raise JSONRPCError("Both message and status parameters are missing. At least one is required.")
|
|
|
|
if status and status not in (st[0] for st in ChangesetStatus.STATUSES):
|
|
raise JSONRPCError(f"Unknown comment status: `{status}`")
|
|
|
|
if commit_id and commit_id not in pull_request.revisions:
|
|
raise JSONRPCError(f"Invalid commit_id `{commit_id}` for this pull request.")
|
|
|
|
allowed_to_change_status = PullRequestModel().check_user_change_status(pull_request, apiuser)
|
|
|
|
# if commit_id is passed re-validated if user is allowed to change status
|
|
# based on the latest commit_id from the PR
|
|
if commit_id:
|
|
commit_idx = pull_request.revisions.index(commit_id)
|
|
if commit_idx != 0:
|
|
log.warning("Resetting allowed_to_change_status = False because commit is NOT the latest in pull-request")
|
|
allowed_to_change_status = False
|
|
|
|
if resolves_comment_id:
|
|
comment = ChangesetComment.get(resolves_comment_id)
|
|
if not comment:
|
|
raise JSONRPCError(f"Invalid resolves_comment_id `{resolves_comment_id}` for this pull request.")
|
|
if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
|
|
raise JSONRPCError(f"Comment `{resolves_comment_id}` is wrong type for setting status to resolved.")
|
|
|
|
text = message
|
|
status_label = ChangesetStatus.get_status_lbl(status)
|
|
if status and allowed_to_change_status:
|
|
st_message = f"Status change > {status_label}"
|
|
text = message or st_message
|
|
|
|
rc_config = SettingsModel().get_all_settings()
|
|
renderer = rc_config.get("rhodecode_markup_renderer", "rst")
|
|
|
|
status_change = status and allowed_to_change_status
|
|
comment = CommentsModel().create(
|
|
text=text,
|
|
repo=pull_request.target_repo.repo_id,
|
|
user=user,
|
|
pull_request=pull_request.pull_request_id,
|
|
f_path=None,
|
|
line_no=None,
|
|
status_change=(status_label if status_change else None),
|
|
status_change_type=(status if status_change else None),
|
|
closing_pr=False,
|
|
renderer=renderer,
|
|
comment_type=comment_type,
|
|
resolves_comment_id=resolves_comment_id,
|
|
auth_user=auth_user,
|
|
extra_recipients=extra_recipients,
|
|
send_email=send_email,
|
|
)
|
|
|
|
is_inline = comment.is_inline
|
|
|
|
if allowed_to_change_status and status:
|
|
old_calculated_status = pull_request.calculated_review_status()
|
|
ChangesetStatusModel().set_status(
|
|
pull_request.target_repo.repo_id,
|
|
status,
|
|
apiuser.user_id,
|
|
comment,
|
|
pull_request=pull_request.pull_request_id,
|
|
)
|
|
Session().flush()
|
|
|
|
Session().commit()
|
|
|
|
PullRequestModel().trigger_pull_request_hook(pull_request, apiuser, "comment", data={"comment": comment})
|
|
|
|
if allowed_to_change_status and status:
|
|
# we now calculate the status of pull request, and based on that
|
|
# calculation we set the commits status
|
|
calculated_status = pull_request.calculated_review_status()
|
|
if old_calculated_status != calculated_status:
|
|
PullRequestModel().trigger_pull_request_hook(
|
|
pull_request, apiuser, "review_status_change", data={"status": calculated_status}
|
|
)
|
|
|
|
data = {
|
|
"pull_request_id": pull_request.pull_request_id,
|
|
"comment_id": comment.comment_id if comment else None,
|
|
"status": {"given": status, "was_changed": status_change},
|
|
}
|
|
|
|
comment_broadcast_channel = channelstream.comment_channel(db_repo_name, pull_request_obj=pull_request)
|
|
|
|
comment_data = data
|
|
comment_type = "inline" if is_inline else "general"
|
|
channelstream.comment_channelstream_push(
|
|
request,
|
|
comment_broadcast_channel,
|
|
apiuser,
|
|
_("posted a new {} comment").format(comment_type),
|
|
comment_data=comment_data,
|
|
)
|
|
|
|
return data
|
|
|
|
|
|
def _reviewers_validation(obj_list):
|
|
schema = ReviewerListSchema()
|
|
try:
|
|
reviewer_objects = schema.deserialize(obj_list)
|
|
except Invalid as err:
|
|
raise JSONRPCValidationError(colander_exc=err)
|
|
|
|
# validate users
|
|
for reviewer_object in reviewer_objects:
|
|
user = get_user_or_error(reviewer_object["username"])
|
|
reviewer_object["user_id"] = user.user_id
|
|
return reviewer_objects
|
|
|
|
|
|
@jsonrpc_method()
|
|
def create_pull_request(
|
|
request,
|
|
apiuser,
|
|
source_repo,
|
|
target_repo,
|
|
source_ref,
|
|
target_ref,
|
|
owner=Optional(OAttr("apiuser")),
|
|
title=Optional(""),
|
|
description=Optional(""),
|
|
description_renderer=Optional(""),
|
|
reviewers=Optional(None),
|
|
observers=Optional(None),
|
|
):
|
|
"""
|
|
Creates a new pull request.
|
|
|
|
Accepts refs in the following formats:
|
|
|
|
* branch:<branch_name>:<sha>
|
|
* branch:<branch_name>
|
|
* bookmark:<bookmark_name>:<sha> (Mercurial only)
|
|
* bookmark:<bookmark_name> (Mercurial only)
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param source_repo: Set the source repository name.
|
|
:type source_repo: str
|
|
:param target_repo: Set the target repository name.
|
|
:type target_repo: str
|
|
:param source_ref: Set the source ref name.
|
|
:type source_ref: str
|
|
:param target_ref: Set the target ref name.
|
|
:type target_ref: str
|
|
:param owner: user_id or username
|
|
:type owner: Optional(str)
|
|
:param title: Optionally Set the pull request title, it's generated otherwise
|
|
:type title: str
|
|
:param description: Set the pull request description.
|
|
:type description: Optional(str)
|
|
:type description_renderer: Optional(str)
|
|
:param description_renderer: Set pull request renderer for the description.
|
|
It should be 'rst', 'markdown' or 'plain'. If not give default
|
|
system renderer will be used
|
|
:param reviewers: Set the new pull request reviewers list.
|
|
Reviewer defined by review rules will be added automatically to the
|
|
defined list.
|
|
:type reviewers: Optional(list)
|
|
Accepts username strings or objects of the format:
|
|
|
|
[{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
|
|
:param observers: Set the new pull request observers list.
|
|
Reviewer defined by review rules will be added automatically to the
|
|
defined list. This feature is only available in RhodeCode EE
|
|
:type observers: Optional(list)
|
|
Accepts username strings or objects of the format:
|
|
|
|
[{'username': 'nick', 'reasons': ['original author']}]
|
|
"""
|
|
|
|
source_db_repo = get_repo_or_error(source_repo)
|
|
target_db_repo = get_repo_or_error(target_repo)
|
|
if not has_superadmin_permission(apiuser):
|
|
_perms = (
|
|
"repository.admin",
|
|
"repository.write",
|
|
"repository.read",
|
|
)
|
|
validate_repo_permissions(apiuser, source_repo, source_db_repo, _perms)
|
|
|
|
owner = validate_set_owner_permissions(apiuser, owner)
|
|
|
|
full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
|
|
full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
|
|
|
|
get_commit_or_error(full_source_ref, source_db_repo)
|
|
get_commit_or_error(full_target_ref, target_db_repo)
|
|
|
|
reviewer_objects = Optional.extract(reviewers) or []
|
|
observer_objects = Optional.extract(observers) or []
|
|
|
|
# serialize and validate passed in given reviewers
|
|
if reviewer_objects:
|
|
reviewer_objects = _reviewers_validation(reviewer_objects)
|
|
|
|
if observer_objects:
|
|
observer_objects = _reviewers_validation(reviewer_objects)
|
|
|
|
get_default_reviewers_data, validate_default_reviewers, validate_observers = (
|
|
PullRequestModel().get_reviewer_functions()
|
|
)
|
|
|
|
source_ref_obj = unicode_to_reference(full_source_ref)
|
|
target_ref_obj = unicode_to_reference(full_target_ref)
|
|
|
|
# recalculate reviewers logic, to make sure we can validate this
|
|
default_reviewers_data = get_default_reviewers_data(
|
|
owner,
|
|
source_db_repo,
|
|
source_ref_obj,
|
|
target_db_repo,
|
|
target_ref_obj,
|
|
)
|
|
|
|
# now MERGE our given with the calculated from the default rules
|
|
just_reviewers = [x for x in default_reviewers_data["reviewers"] if x["role"] == PullRequestReviewers.ROLE_REVIEWER]
|
|
reviewer_objects = just_reviewers + reviewer_objects
|
|
|
|
try:
|
|
reviewers = validate_default_reviewers(reviewer_objects, default_reviewers_data)
|
|
except ValueError as e:
|
|
raise JSONRPCError(f"Reviewers Validation: {e}")
|
|
|
|
# now MERGE our given with the calculated from the default rules
|
|
just_observers = [x for x in default_reviewers_data["reviewers"] if x["role"] == PullRequestReviewers.ROLE_OBSERVER]
|
|
observer_objects = just_observers + observer_objects
|
|
|
|
try:
|
|
observers = validate_observers(observer_objects, default_reviewers_data)
|
|
except ValueError as e:
|
|
raise JSONRPCError(f"Observer Validation: {e}")
|
|
|
|
title = Optional.extract(title)
|
|
if not title:
|
|
title_source_ref = source_ref_obj.name
|
|
title = PullRequestModel().generate_pullrequest_title(
|
|
source=source_repo, source_ref=title_source_ref, target=target_repo
|
|
)
|
|
|
|
diff_info = default_reviewers_data["diff_info"]
|
|
common_ancestor_id = diff_info["ancestor"]
|
|
# NOTE(marcink): reversed is consistent with how we open it in the WEB interface
|
|
commits = [commit["commit_id"] for commit in reversed(diff_info["commits"])]
|
|
|
|
if not common_ancestor_id:
|
|
raise JSONRPCError("no common ancestor found between specified references")
|
|
|
|
if not commits:
|
|
raise JSONRPCError("no commits found for merge between specified references")
|
|
|
|
# recalculate target ref based on ancestor
|
|
full_target_ref = ":".join((target_ref_obj.type, target_ref_obj.name, common_ancestor_id))
|
|
|
|
# fetch renderer, if set fallback to plain in case of PR
|
|
rc_config = SettingsModel().get_all_settings()
|
|
default_system_renderer = rc_config.get("rhodecode_markup_renderer", "plain")
|
|
description = Optional.extract(description)
|
|
description_renderer = Optional.extract(description_renderer) or default_system_renderer
|
|
|
|
pull_request = PullRequestModel().create(
|
|
created_by=owner.user_id,
|
|
source_repo=source_repo,
|
|
source_ref=full_source_ref,
|
|
target_repo=target_repo,
|
|
target_ref=full_target_ref,
|
|
common_ancestor_id=common_ancestor_id,
|
|
revisions=commits,
|
|
reviewers=reviewers,
|
|
observers=observers,
|
|
title=title,
|
|
description=description,
|
|
description_renderer=description_renderer,
|
|
reviewer_data=default_reviewers_data,
|
|
auth_user=apiuser,
|
|
)
|
|
|
|
Session().commit()
|
|
data = {
|
|
"msg": f"Created new pull request `{title}`",
|
|
"pull_request_id": pull_request.pull_request_id,
|
|
}
|
|
return data
|
|
|
|
|
|
@jsonrpc_method()
|
|
def update_pull_request(
|
|
request,
|
|
apiuser,
|
|
pullrequestid,
|
|
repoid=Optional(None),
|
|
title=Optional(""),
|
|
description=Optional(""),
|
|
description_renderer=Optional(""),
|
|
reviewers=Optional(None),
|
|
observers=Optional(None),
|
|
update_commits=Optional(None),
|
|
):
|
|
"""
|
|
Updates a pull request.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Optional repository name or repository ID.
|
|
:type repoid: str or int
|
|
:param pullrequestid: The pull request ID.
|
|
:type pullrequestid: int
|
|
:param title: Set the pull request title.
|
|
:type title: str
|
|
:param description: Update pull request description.
|
|
:type description: Optional(str)
|
|
:type description_renderer: Optional(str)
|
|
:param description_renderer: Update pull request renderer for the description.
|
|
It should be 'rst', 'markdown' or 'plain'
|
|
:param reviewers: Update pull request reviewers list with new value.
|
|
:type reviewers: Optional(list)
|
|
Accepts username strings or objects of the format:
|
|
|
|
[{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
|
|
:param observers: Update pull request observers list with new value.
|
|
:type observers: Optional(list)
|
|
Accepts username strings or objects of the format:
|
|
|
|
[{'username': 'nick', 'reasons': ['should be aware about this PR']}]
|
|
:param update_commits: Trigger update of commits for this pull request
|
|
:type: update_commits: Optional(bool)
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
id : <id_given_in_input>
|
|
result : {
|
|
"msg": "Updated pull request `63`",
|
|
"pull_request": <pull_request_object>,
|
|
"updated_reviewers": {
|
|
"added": [
|
|
"username"
|
|
],
|
|
"removed": []
|
|
},
|
|
"updated_observers": {
|
|
"added": [
|
|
"username"
|
|
],
|
|
"removed": []
|
|
},
|
|
"updated_commits": {
|
|
"added": [
|
|
"<sha1_hash>"
|
|
],
|
|
"common": [
|
|
"<sha1_hash>",
|
|
"<sha1_hash>",
|
|
],
|
|
"removed": []
|
|
}
|
|
}
|
|
error : null
|
|
"""
|
|
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
if not PullRequestModel().check_user_update(pull_request, apiuser, api=True):
|
|
raise JSONRPCError(f"pull request `{pullrequestid}` update failed, no permission to update.")
|
|
if pull_request.is_closed():
|
|
raise JSONRPCError(f"pull request `{pullrequestid}` update failed, pull request is closed")
|
|
|
|
reviewer_objects = Optional.extract(reviewers) or []
|
|
observer_objects = Optional.extract(observers) or []
|
|
|
|
title = Optional.extract(title)
|
|
description = Optional.extract(description)
|
|
description_renderer = Optional.extract(description_renderer)
|
|
|
|
# Update title/description
|
|
title_changed = False
|
|
if title or description:
|
|
PullRequestModel().edit(
|
|
pull_request,
|
|
title or pull_request.title,
|
|
description or pull_request.description,
|
|
description_renderer or pull_request.description_renderer,
|
|
apiuser,
|
|
)
|
|
Session().commit()
|
|
title_changed = True
|
|
|
|
commit_changes = {"added": [], "common": [], "removed": []}
|
|
|
|
# Update commits
|
|
commits_changed = False
|
|
if str2bool(Optional.extract(update_commits)):
|
|
if pull_request.pull_request_state != PullRequest.STATE_CREATED:
|
|
raise JSONRPCError(
|
|
f"Operation forbidden because pull request is in state {pull_request.pull_request_state}, only state {PullRequest.STATE_CREATED} is allowed."
|
|
)
|
|
|
|
with pull_request.set_state(PullRequest.STATE_UPDATING):
|
|
if PullRequestModel().has_valid_update_type(pull_request):
|
|
db_user = apiuser.get_instance()
|
|
update_response = PullRequestModel().update_commits(pull_request, db_user)
|
|
commit_changes = update_response.changes or commit_changes
|
|
Session().commit()
|
|
commits_changed = True
|
|
|
|
# Update reviewers
|
|
# serialize and validate passed in given reviewers
|
|
if reviewer_objects:
|
|
reviewer_objects = _reviewers_validation(reviewer_objects)
|
|
|
|
if observer_objects:
|
|
observer_objects = _reviewers_validation(reviewer_objects)
|
|
|
|
# re-use stored rules
|
|
default_reviewers_data = pull_request.reviewer_data
|
|
|
|
__, validate_default_reviewers, validate_observers = PullRequestModel().get_reviewer_functions()
|
|
|
|
if reviewer_objects:
|
|
try:
|
|
reviewers = validate_default_reviewers(reviewer_objects, default_reviewers_data)
|
|
except ValueError as e:
|
|
raise JSONRPCError(f"Reviewers Validation: {e}")
|
|
else:
|
|
reviewers = []
|
|
|
|
if observer_objects:
|
|
try:
|
|
observers = validate_default_reviewers(reviewer_objects, default_reviewers_data)
|
|
except ValueError as e:
|
|
raise JSONRPCError(f"Observer Validation: {e}")
|
|
else:
|
|
observers = []
|
|
|
|
reviewers_changed = False
|
|
reviewers_changes = {"added": [], "removed": []}
|
|
if reviewers:
|
|
old_calculated_status = pull_request.calculated_review_status()
|
|
added_reviewers, removed_reviewers = PullRequestModel().update_reviewers(
|
|
pull_request, reviewers, apiuser.get_instance()
|
|
)
|
|
|
|
reviewers_changes["added"] = sorted([get_user_or_error(n).username for n in added_reviewers])
|
|
reviewers_changes["removed"] = sorted([get_user_or_error(n).username for n in removed_reviewers])
|
|
Session().commit()
|
|
|
|
# trigger status changed if change in reviewers changes the status
|
|
calculated_status = pull_request.calculated_review_status()
|
|
if old_calculated_status != calculated_status:
|
|
PullRequestModel().trigger_pull_request_hook(
|
|
pull_request, apiuser, "review_status_change", data={"status": calculated_status}
|
|
)
|
|
reviewers_changed = True
|
|
|
|
observers_changed = False
|
|
observers_changes = {"added": [], "removed": []}
|
|
if observers:
|
|
added_observers, removed_observers = PullRequestModel().update_observers(
|
|
pull_request, observers, apiuser.get_instance()
|
|
)
|
|
|
|
observers_changes["added"] = sorted([get_user_or_error(n).username for n in added_observers])
|
|
observers_changes["removed"] = sorted([get_user_or_error(n).username for n in removed_observers])
|
|
Session().commit()
|
|
|
|
reviewers_changed = True
|
|
|
|
# push changed to channelstream
|
|
if commits_changed or reviewers_changed or observers_changed:
|
|
pr_broadcast_channel = channelstream.pr_channel(pull_request)
|
|
msg = "Pull request was updated."
|
|
channelstream.pr_update_channelstream_push(request, pr_broadcast_channel, apiuser, msg)
|
|
|
|
data = {
|
|
"msg": f"Updated pull request `{pull_request.pull_request_id}`",
|
|
"pull_request": pull_request.get_api_data(),
|
|
"updated_commits": commit_changes,
|
|
"updated_reviewers": reviewers_changes,
|
|
"updated_observers": observers_changes,
|
|
}
|
|
|
|
return data
|
|
|
|
|
|
@jsonrpc_method()
|
|
def close_pull_request(
|
|
request, apiuser, pullrequestid, repoid=Optional(None), userid=Optional(OAttr("apiuser")), message=Optional("")
|
|
):
|
|
"""
|
|
Close the pull request specified by `pullrequestid`.
|
|
|
|
:param apiuser: This is filled automatically from the |authtoken|.
|
|
:type apiuser: AuthUser
|
|
:param repoid: Repository name or repository ID to which the pull
|
|
request belongs.
|
|
:type repoid: str or int
|
|
:param pullrequestid: ID of the pull request to be closed.
|
|
:type pullrequestid: int
|
|
:param userid: Close the pull request as this user.
|
|
:type userid: Optional(str or int)
|
|
:param message: Optional message to close the Pull Request with. If not
|
|
specified it will be generated automatically.
|
|
:type message: Optional(str)
|
|
|
|
Example output:
|
|
|
|
.. code-block:: bash
|
|
|
|
"id": <id_given_in_input>,
|
|
"result": {
|
|
"pull_request_id": "<int>",
|
|
"close_status": "<str:status_lbl>,
|
|
"closed": "<bool>"
|
|
},
|
|
"error": null
|
|
|
|
"""
|
|
_ = request.translate
|
|
|
|
pull_request = get_pull_request_or_error(pullrequestid)
|
|
if Optional.extract(repoid):
|
|
repo = get_repo_or_error(repoid)
|
|
else:
|
|
repo = pull_request.target_repo
|
|
|
|
auth_user = apiuser
|
|
if not isinstance(userid, Optional):
|
|
if has_superadmin_permission(apiuser):
|
|
# super-admin can impersonate other users
|
|
auth_user = get_user_or_error(userid)
|
|
else:
|
|
raise JSONRPCError("Provided userid is not the same the user calling this function")
|
|
|
|
if pull_request.is_closed():
|
|
raise JSONRPCError(f"pull request `{pullrequestid}` is already closed")
|
|
|
|
# only owner or admin or person with write permissions
|
|
allowed_to_close = PullRequestModel().check_user_update(pull_request, apiuser, api=True)
|
|
|
|
if not allowed_to_close:
|
|
raise JSONRPCError(f"pull request `{pullrequestid}` close failed, no permission to close.")
|
|
|
|
# message we're using to close the PR, else it's automatically generated
|
|
message = Optional.extract(message)
|
|
|
|
# finally close the PR, with proper message comment
|
|
comment, status = PullRequestModel().close_pull_request_with_comment(
|
|
pull_request, apiuser, repo, message=message, auth_user=auth_user
|
|
)
|
|
status_lbl = ChangesetStatus.get_status_lbl(status)
|
|
|
|
Session().commit()
|
|
|
|
data = {
|
|
"pull_request_id": pull_request.pull_request_id,
|
|
"close_status": status_lbl,
|
|
"closed": True,
|
|
}
|
|
return data
|