# -*- coding: utf-8 -*-

"""

 (c) 2014-2017 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

# pylint: disable=too-many-return-statements

# pylint: disable=too-many-branches

# pylint: disable=too-many-arguments

# pylint: disable=too-many-locals

# pylint: disable=too-many-statements

# pylint: disable=too-many-lines

from __future__ import unicode_literals, absolute_import

import logging

import os

from math import ceil

import flask

import pygit2

from sqlalchemy.exc import SQLAlchemyError

import pagure

import pagure.doc_utils

import pagure.exceptions

import pagure.lib.git

import pagure.lib.plugins

import pagure.lib.query

import pagure.lib.tasks

import pagure.forms

from pagure.config import config as pagure_config

from pagure.ui import UI_NS

from pagure.utils import (

    login_required,

    __get_file_in_tree,

    get_parent_repo_path,

    is_true,

)

_log = logging.getLogger(__name__)

def _get_parent_request_repo_path(repo):

    """ Return the path of the parent git repository corresponding to the

    provided Repository object from the DB.

    """

    if repo.parent:

        return repo.parent.repopath("requests")

    else:

        return repo.repopath("requests")

@UI_NS.route("/<repo>/pull-requests/")</repo>

@UI_NS.route("/<repo>/pull-requests")</repo>

@UI_NS.route("/<namespace>/<repo>/pull-requests/")</repo></namespace>

@UI_NS.route("/<namespace>/<repo>/pull-requests")</repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/pull-requests/")</repo></username>

@UI_NS.route("/fork/<username>/<repo>/pull-requests")</repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/pull-requests/")</repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/pull-requests")</repo></namespace></username>

def request_pulls(repo, username=None, namespace=None):

    """ List all Pull-requests associated to a repo

    """

    status = flask.request.args.get("status", "Open")

    assignee = flask.request.args.get("assignee", None)

    search_pattern = flask.request.args.get("search_pattern", None)

    author = flask.request.args.get("author", None)

    order = flask.request.args.get("order", "desc")

    order_key = flask.request.args.get("order_key", "date_created")

    repo = flask.g.repo

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    total_open = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, status=True, count=True

    )

    total_merged = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, status="Merged", count=True

    )

    if status.lower() == "merged" or is_true(status, ["false", "0"]):

        status_filter = "Merged"

        requests = pagure.lib.query.search_pull_requests(

            flask.g.session,

            project_id=repo.id,

            status="Merged",

            order=order,

            order_key=order_key,

            assignee=assignee,

            author=author,

            search_pattern=search_pattern,

            offset=flask.g.offset,

            limit=flask.g.limit,

        )

    elif is_true(status, ["true", "1", "open"]):

        status_filter = "Open"

        requests = pagure.lib.query.search_pull_requests(

            flask.g.session,

            project_id=repo.id,

            status="Open",

            order=order,

            order_key=order_key,

            assignee=assignee,

            author=author,

            search_pattern=search_pattern,

            offset=flask.g.offset,

            limit=flask.g.limit,

        )

    elif status.lower() == "closed":

        status_filter = "Closed"

        requests = pagure.lib.query.search_pull_requests(

            flask.g.session,

            project_id=repo.id,

            status="Closed",

            order=order,

            order_key=order_key,

            assignee=assignee,

            author=author,

            search_pattern=search_pattern,

            offset=flask.g.offset,

            limit=flask.g.limit,

        )

    else:

        status_filter = None

        requests = pagure.lib.query.search_pull_requests(

            flask.g.session,

            project_id=repo.id,

            status=None,

            order=order,

            order_key=order_key,

            assignee=assignee,

            author=author,

            search_pattern=search_pattern,

            offset=flask.g.offset,

            limit=flask.g.limit,

        )

    open_cnt = pagure.lib.query.search_pull_requests(

        flask.g.session,

        project_id=repo.id,

        status="Open",

        assignee=assignee,

        author=author,

        search_pattern=search_pattern,

        count=True,

    )

    merged_cnt = pagure.lib.query.search_pull_requests(

        flask.g.session,

        project_id=repo.id,

        status="Merged",

        assignee=assignee,

        author=author,

        search_pattern=search_pattern,

        count=True,

    )

    closed_cnt = pagure.lib.query.search_pull_requests(

        flask.g.session,

        project_id=repo.id,

        status="Closed",

        assignee=assignee,

        author=author,

        search_pattern=search_pattern,

        count=True,

    )

    repo_obj = flask.g.repo_obj

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        head = repo_obj.head.shorthand

    else:

        head = "master"

    total_page = 1

    if len(requests):

        if status_filter == "Closed":

            total_requests = closed_cnt

        elif status_filter == "Merged":

            total_requests = merged_cnt

        elif status_filter == "Open":

            total_requests = open_cnt

        else:

            total_requests = closed_cnt + merged_cnt + open_cnt

        total_page = int(ceil(total_requests / float(flask.g.limit)))

    return flask.render_template(

        "requests.html",

        select="requests",

        repo=repo,

        username=username,

        requests=requests,

        open_cnt=open_cnt,

        merged_cnt=merged_cnt,

        closed_cnt=closed_cnt,

        order=order,

        order_key=order_key,

        status=status,

        status_filter=status_filter,

        assignee=assignee,

        author=author,

        search_pattern=search_pattern,

        head=head,

        total_page=total_page,

        total_open=total_open,

        total_merged=total_merged,

    )

@UI_NS.route("/<repo>/pull-request/<int:requestid>/")</int:requestid></repo>

@UI_NS.route("/<repo>/pull-request/<int:requestid>")</int:requestid></repo>

@UI_NS.route("/<namespace>/<repo>/pull-request/<int:requestid>/")</int:requestid></repo></namespace>

@UI_NS.route("/<namespace>/<repo>/pull-request/<int:requestid>")</int:requestid></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/pull-request/<int:requestid>/")</int:requestid></repo></username>

@UI_NS.route("/fork/<username>/<repo>/pull-request/<int:requestid>")</int:requestid></repo></username>

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>/"</int:requestid></repo></namespace></username>

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>"</int:requestid></repo></namespace></username>

)

def request_pull(repo, requestid, username=None, namespace=None):

    """ Create a pull request with the changes from the fork into the project.

    """

    repo = flask.g.repo

    _log.info("Viewing pull Request #%s repo: %s", requestid, repo.fullname)

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    if request.remote:

        repopath = pagure.utils.get_remote_repo_path(

            request.remote_git, request.branch_from

        )

        parentpath = pagure.utils.get_repo_path(request.project)

    else:

        repo_from = request.project_from

        parentpath = pagure.utils.get_repo_path(request.project)

        repopath = parentpath

        if repo_from:

            repopath = pagure.utils.get_repo_path(repo_from)

    repo_obj = pygit2.Repository(repopath)

    orig_repo = pygit2.Repository(parentpath)

    diff_commits = []

    diff = None

    # Closed pull-request

    if request.status != "Open":

        commitid = request.commit_stop

        try:

            for commit in repo_obj.walk(commitid, pygit2.GIT_SORT_NONE):

                diff_commits.append(commit)

                if commit.oid.hex == request.commit_start:

                    break

        except KeyError:

            # This happens when repo.walk() cannot find commitid

            pass

        if diff_commits:

            # Ensure the first commit in the PR as a parent, otherwise

            # point to it

            start = diff_commits[-1].oid.hex

            if diff_commits[-1].parents:

                start = diff_commits[-1].parents[0].oid.hex

            # If the start and the end commits are the same, it means we are,

            # dealing with one commit that has no parent, so just diff that

            # one commit

            if start == diff_commits[0].oid.hex:

                diff = diff_commits[0].tree.diff_to_tree(swap=True)

            else:

                diff = repo_obj.diff(

                    repo_obj.revparse_single(start),

                    repo_obj.revparse_single(diff_commits[0].oid.hex),

                )

    else:

        try:

            diff_commits, diff = pagure.lib.git.diff_pull_request(

                flask.g.session, request, repo_obj, orig_repo

            )

        except pagure.exceptions.PagureException as err:

            flask.flash("%s" % err, "error")

        except SQLAlchemyError as err:  # pragma: no cover

            flask.g.session.rollback()

            _log.exception(err)

            flask.flash(

                "Could not update this pull-request in the database", "error"

            )

    if diff:

        diff.find_similar()

    form = pagure.forms.MergePRForm()

    trigger_ci_pr_form = pagure.forms.TriggerCIPRForm()

    # we need to leave out all members of trigger_ci_conf that have

    # "meta" set to False or meta["requires_project_hook_attr"] condition

    # defined and it's not met

    trigger_ci_conf = pagure_config["TRIGGER_CI"]

    if not isinstance(trigger_ci_conf, dict):

        trigger_ci_conf = {}

    trigger_ci = {}

    # make sure all the backrefs are set properly on repo

    pagure.lib.plugins.get_enabled_plugins(repo)

    for comment, meta in trigger_ci_conf.items():

        if not meta:

            continue

        cond = meta.get("requires_project_hook_attr", ())

        if cond and not pagure.utils.project_has_hook_attr_value(repo, *cond):

            continue

        trigger_ci[comment] = meta

    can_delete_branch = (

        pagure_config.get("ALLOW_DELETE_BRANCH", True)

        and not request.remote_git

        and request.project_from

        and pagure.utils.is_repo_committer(request.project_from)

    )

    return flask.render_template(

        "repo_pull_request.html",

        select="requests",

        requestid=requestid,

        repo=repo,

        username=username,

        repo_obj=repo_obj,

        pull_request=request,

        diff_commits=diff_commits,

        diff=diff,

        mergeform=form,

        subscribers=pagure.lib.query.get_watch_list(flask.g.session, request),

        tag_list=pagure.lib.query.get_tags_of_project(flask.g.session, repo),

        can_delete_branch=can_delete_branch,

        trigger_ci=trigger_ci,

        trigger_ci_pr_form=trigger_ci_pr_form,

    )

@UI_NS.route("/<repo>/pull-request/<int:requestid>.patch")</int:requestid></repo>

@UI_NS.route("/<namespace>/<repo>/pull-request/<int:requestid>.patch")</int:requestid></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/pull-request/<int:requestid>.patch")</int:requestid></repo></username>

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>.patch"</int:requestid></repo></namespace></username>

)

def request_pull_patch(repo, requestid, username=None, namespace=None):

    """ Returns the commits from the specified pull-request as patches.

    """

    return request_pull_to_diff_or_patch(

        repo, requestid, username, namespace, diff=False

    )

@UI_NS.route("/<repo>/pull-request/<int:requestid>.diff")</int:requestid></repo>

@UI_NS.route("/<namespace>/<repo>/pull-request/<int:requestid>.diff")</int:requestid></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/pull-request/<int:requestid>.diff")</int:requestid></repo></username>

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>.diff"</int:requestid></repo></namespace></username>

)

def request_pull_diff(repo, requestid, username=None, namespace=None):

    """ Returns the commits from the specified pull-request as patches.

    """

    return request_pull_to_diff_or_patch(

        repo, requestid, username, namespace, diff=True

    )

def request_pull_to_diff_or_patch(

    repo, requestid, username=None, namespace=None, diff=False

):

    """ Returns the commits from the specified pull-request as patches.

    :arg repo: the `pagure.lib.model.Project` object of the current pagure

        project browsed

    :type repo: `pagure.lib.model.Project`

    :arg requestid: the identifier of the pull-request to convert to patch

        or diff

    :type requestid: int

    :kwarg username: the username of the user who forked then project when

        the project viewed is a fork

    :type username: str or None

    :kwarg namespace: the namespace of the project if it has one

    :type namespace: str or None

    :kwarg diff: a boolean whether the data returned is a patch or a diff

    :type diff: boolean

    :return: the patch or diff representation of the specified pull-request

    :rtype: str

    """

    repo = flask.g.repo

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    if request.remote:

        repopath = pagure.utils.get_remote_repo_path(

            request.remote_git, request.branch_from

        )

        parentpath = pagure.utils.get_repo_path(request.project)

    else:

        repo_from = request.project_from

        parentpath = pagure.utils.get_repo_path(request.project)

        repopath = parentpath

        if repo_from:

            repopath = pagure.utils.get_repo_path(repo_from)

    repo_obj = pygit2.Repository(repopath)

    orig_repo = pygit2.Repository(parentpath)

    branch = repo_obj.lookup_branch(request.branch_from)

    commitid = None

    if branch:

        commitid = branch.peel().hex

    diff_commits = []

    if request.status != "Open":

        commitid = request.commit_stop

        try:

            for commit in repo_obj.walk(commitid, pygit2.GIT_SORT_NONE):

                diff_commits.append(commit)

                if commit.oid.hex == request.commit_start:

                    break

        except KeyError:

            # This happens when repo.walk() cannot find commitid

            pass

    else:

        try:

            diff_commits = pagure.lib.git.diff_pull_request(

                flask.g.session, request, repo_obj, orig_repo, with_diff=False

            )

        except pagure.exceptions.PagureException as err:

            flask.flash("%s" % err, "error")

            return flask.redirect(

                flask.url_for(

                    "ui_ns.view_repo",

                    username=username,

                    repo=repo.name,

                    namespace=namespace,

                )

            )

        except SQLAlchemyError as err:  # pragma: no cover

            flask.g.session.rollback()

            _log.exception(err)

            flask.flash(

                "Could not update this pull-request in the database", "error"

            )

    diff_commits.reverse()

    patch = pagure.lib.git.commit_to_patch(

        repo_obj, diff_commits, diff_view=diff

    )

    return flask.Response(patch, content_type="text/plain;charset=UTF-8")

@UI_NS.route(

    "/<repo>/pull-request/<int:requestid>/edit/", methods=("GET", "POST")</int:requestid></repo>

)

@UI_NS.route(

    "/<repo>/pull-request/<int:requestid>/edit", methods=("GET", "POST")</int:requestid></repo>

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/edit/",</int:requestid></repo></namespace>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/edit",</int:requestid></repo></namespace>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/edit/",</int:requestid></repo></username>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/edit",</int:requestid></repo></username>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>/edit/",</int:requestid></repo></namespace></username>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>/edit",</int:requestid></repo></namespace></username>

    methods=("GET", "POST"),

)

@login_required

def request_pull_edit(repo, requestid, username=None, namespace=None):

    """ Edit the title of a pull-request.

    """

    repo = flask.g.repo

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    if request.status != "Open":

        flask.abort(400, description="Pull-request is already closed")

    if (

        not flask.g.repo_committer

        and flask.g.fas_user.username != request.user.username

    ):

        flask.abort(

            403, description="You are not allowed to edit this pull-request"

        )

    form = pagure.forms.RequestPullForm()

    if form.validate_on_submit():

        request.title = form.title.data.strip()

        request.initial_comment = form.initial_comment.data.strip()

        flask.g.session.add(request)

        if not request.private and not request.project.private:

            pagure.lib.notify.log(

                request.project,

                topic="pull-request.initial_comment.edited",

                msg={

                    "pullrequest": request.to_json(

                        public=True, with_comments=False

                    ),

                    "project": request.project.to_json(public=True),

                    "agent": flask.g.fas_user.username,

                },

            )

        try:

            # Link the PR to issue(s) if there is such link

            pagure.lib.query.link_pr_to_issue_on_description(

                flask.g.session, request

            )

            flask.g.session.commit()

            flask.flash("Pull request edited!")

        except SQLAlchemyError as err:  # pragma: no cover

            flask.g.session.rollback()

            _log.exception(err)

            flask.flash(

                "Could not edit this pull-request in the database", "error"

            )

        return flask.redirect(

            flask.url_for(

                "ui_ns.request_pull",

                username=username,

                namespace=namespace,

                repo=repo.name,

                requestid=requestid,

            )

        )

    elif flask.request.method == "GET":

        form.title.data = request.title

        form.initial_comment.data = request.initial_comment

    return flask.render_template(

        "pull_request_title.html",

        select="requests",

        request=request,

        repo=repo,

        username=username,

        form=form,

    )

@UI_NS.route("/<repo>/pull-request/<int:requestid>/comment", methods=["POST"])</int:requestid></repo>

@UI_NS.route(

    "/<repo>/pull-request/<int:requestid>/comment/<commit>/"</commit></int:requestid></repo>

    "<path:filename>/<row>",</row></path:filename>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/comment",</int:requestid></repo></namespace>

    methods=["POST"],

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/comment/<commit>/"</commit></int:requestid></repo></namespace>

    "<path:filename>/<row>",</row></path:filename>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/comment",</int:requestid></repo></username>

    methods=["POST"],

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/comment/"</int:requestid></repo></username>

    "<commit>/<path:filename>/<row>",</row></path:filename></commit>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>/"</int:requestid></repo></namespace></username>

    "comment",

    methods=["POST"],

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/<int:requestid>/"</int:requestid></repo></namespace></username>

    "comment/<commit>/<path:filename>/<row>",</row></path:filename></commit>

    methods=("GET", "POST"),

)

@login_required

def pull_request_add_comment(

    repo,

    requestid,

    commit=None,

    filename=None,

    row=None,

    username=None,

    namespace=None,

):

    """ Add a comment to a commit in a pull-request.

    """

    repo = flask.g.repo

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    is_js = flask.request.args.get("js", False)

    tree_id = flask.request.args.get("tree_id") or None

    form = pagure.forms.AddPullRequestCommentForm()

    form.commit.data = commit

    form.filename.data = filename

    form.requestid.data = requestid

    form.row.data = row

    form.tree_id.data = tree_id

    if form.validate_on_submit():

        comment = form.comment.data

        try:

            trigger_ci = pagure_config["TRIGGER_CI"]

            if isinstance(trigger_ci, dict):

                trigger_ci = list(trigger_ci.keys())

            message = pagure.lib.query.add_pull_request_comment(

                flask.g.session,

                request=request,

                commit=commit,

                tree_id=tree_id,

                filename=filename,

                row=row,

                comment=comment,

                user=flask.g.fas_user.username,

                trigger_ci=trigger_ci,

            )

            flask.g.session.commit()

            if not is_js:

                flask.flash(message)

        except SQLAlchemyError as err:  # pragma: no cover

            flask.g.session.rollback()

            _log.exception(err)

            if is_js:

                return "error"

            else:

                flask.flash(str(err), "error")

        if is_js:

            return "ok"

        return flask.redirect(

            flask.url_for(

                "ui_ns.request_pull",

                username=username,

                namespace=namespace,

                repo=repo.name,

                requestid=requestid,

            )

        )

    if is_js and flask.request.method == "POST":

        return "failed"

    return flask.render_template(

        "pull_request_comment.html",

        select="requests",

        requestid=requestid,

        repo=repo,

        username=username,

        commit=commit,

        tree_id=tree_id,

        filename=filename,

        row=row,

        form=form,

    )

@UI_NS.route(

    "/<repo>/pull-request/<int:requestid>/comment/drop", methods=["POST"]</int:requestid></repo>

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/comment/drop",</int:requestid></repo></namespace>

    methods=["POST"],

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/comment/drop",</int:requestid></repo></username>

    methods=["POST"],

)

@UI_NS.route(

    "/fork/<namespace>/<username>/<repo>/pull-request/<int:requestid>/"</int:requestid></repo></username></namespace>

    "comment/drop",

    methods=["POST"],

)

@login_required

def pull_request_drop_comment(repo, requestid, username=None, namespace=None):

    """ Delete a comment of a pull-request.

    """

    repo = flask.g.repo

    if not repo:

        flask.abort(404, description="Project not found")

    if not repo.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=repo.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    if flask.request.form.get("edit_comment"):

        commentid = flask.request.form.get("edit_comment")

        form = pagure.forms.EditCommentForm()

        if form.validate_on_submit():

            return pull_request_edit_comment(

                repo.name, requestid, commentid, username=username

            )

    form = pagure.forms.ConfirmationForm()

    if form.validate_on_submit():

        if flask.request.form.get("drop_comment"):

            commentid = flask.request.form.get("drop_comment")

            comment = pagure.lib.query.get_request_comment(

                flask.g.session, request.uid, commentid

            )

            if comment is None or comment.pull_request.project != repo:

                flask.abort(404, description="Comment not found")

            if (

                flask.g.fas_user.username != comment.user.username

                or comment.parent.status is False

            ) and not flask.g.repo_committer:

                flask.abort(

                    403,

                    description="You are not allowed to remove this comment "

                    "from this issue",

                )

            flask.g.session.delete(comment)

            try:

                flask.g.session.commit()

                flask.flash("Comment removed")

            except SQLAlchemyError as err:  # pragma: no cover

                flask.g.session.rollback()

                _log.error(err)

                flask.flash(

                    "Could not remove the comment: %s" % commentid, "error"

                )

    return flask.redirect(

        flask.url_for(

            "ui_ns.request_pull",

            username=username,

            namespace=namespace,

            repo=repo.name,

            requestid=requestid,

        )

    )

@UI_NS.route(

    "/<repo>/pull-request/<int:requestid>/comment/<int:commentid>/edit",</int:commentid></int:requestid></repo>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/<namespace>/<repo>/pull-request/<int:requestid>/comment/"</int:requestid></repo></namespace>

    "<int:commentid>/edit",</int:commentid>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<repo>/pull-request/<int:requestid>/comment"</int:requestid></repo></username>

    "/<int:commentid>/edit",</int:commentid>

    methods=("GET", "POST"),

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/pull-request/"</repo></namespace></username>

    "<int:requestid>/comment/<int:commentid>/edit",</int:commentid></int:requestid>

    methods=("GET", "POST"),

)

@login_required

def pull_request_edit_comment(

    repo, requestid, commentid, username=None, namespace=None

):

    """Edit comment of a pull request

    """

    is_js = flask.request.args.get("js", False)

    project = flask.g.repo

    if not project.settings.get("pull_requests", True):

        flask.abort(404, description="No pull-requests found for this project")

    request = pagure.lib.query.search_pull_requests(

        flask.g.session, project_id=project.id, requestid=requestid

    )

    if not request:

        flask.abort(404, description="Pull-request not found")

    comment = pagure.lib.query.get_request_comment(

        flask.g.session, request.uid, commentid

    )

    if comment is None or comment.parent.project != project:

        flask.abort(404, description="Comment not found")

    if (

        flask.g.fas_user.username != comment.user.username

        or comment.parent.status != "Open"

    ) and not flask.g.repo_committer:

        flask.abort(403, description="You are not allowed to edit the comment")

    form = pagure.forms.EditCommentForm()

    if form.validate_on_submit():

        updated_comment = form.update_comment.data

        try:

            message = pagure.lib.query.edit_comment(

                flask.g.session,

                parent=request,

                comment=comment,

                user=flask.g.fas_user.username,

                updated_comment=updated_comment,

            )

            flask.g.session.commit()

            if not is_js:

                flask.flash(message)

        except SQLAlchemyError as err:  # pragma: no cover

            flask.g.session.rollback()

            _log.error(err)

            if is_js:

                return "error"

            else:

                flask.flash(

                    "Could not edit the comment: %s" % commentid, "error"

                )