"""

kallithea.controllers.admin.gists

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

gist controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode.htmlfill

from sqlalchemy.sql.expression import or_

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_str, time_to_datetime

from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

log = logging.getLogger(__name__)

class GistsController(BaseController):

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            raise HTTPFound(location=url('new_gist'))

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

    def new(self, format='html'):

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.owner_id == request.authuser.user_id

            GistModel().delete(gist)

            meta.Session().commit()

            h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')

        else:

            raise HTTPForbidden()

        raise HTTPFound(location=url('gists'))

    @LoginRequired(allow_default_user=True)

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = db.Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id,

                                                            revision=revision)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            content = '\n\n'.join(

kallithea.controllers.changeset

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

changeset controller showing changes between revisions

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 25, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import binascii

import logging

import traceback

from collections import OrderedDict

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import ascii_str, safe_str

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.pull_request import PullRequestModel

log = logging.getLogger(__name__)

def create_cs_pr_comment(repo_name, revision=None, pull_request=None, allowed_to_change_status=True):

    """

    Add a comment to the specified changeset or pull request, using POST values

    from the request.

    Comments can be inline (when a file path and line number is specified in

    POST) or general comments.

    A comment can be accompanied by a review status change (accepted, rejected,

    assert request.environ.get('HTTP_X_PARTIAL_XHR')

    if pull_request:

        pull_request_id = pull_request.pull_request_id

    else:

        pull_request_id = None

    status = request.POST.get('changeset_status')

    close_pr = request.POST.get('save_close')

    delete = request.POST.get('save_delete')

    f_path = request.POST.get('f_path')

    line_no = request.POST.get('line')

    if (status or close_pr or delete) and (f_path or line_no):

        # status votes and closing is only possible in general comments

        raise HTTPBadRequest()

    if not allowed_to_change_status:

        if status or close_pr:

            h.flash(_('No permission to change status'), 'error')

            raise HTTPForbidden()

    if pull_request and delete == "delete":

        if (pull_request.owner_id == request.authuser.user_id or

        ) and not pull_request.is_closed():

            PullRequestModel().delete(pull_request)

            meta.Session().commit()

            h.flash(_('Successfully deleted pull request %s') % pull_request_id,

                    category='success')

            return {

               'location': webutils.url('my_pullrequests'), # or repo pr list?

            }

        raise HTTPForbidden()

    text = request.POST.get('text', '').strip()

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        author=request.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path or None,

        line_no=line_no or None,

        status_change=db.ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=close_pr,

    )

    meta.Session().commit()

    data = {

       'target_id': h.safeid(request.POST.get('f_path')),

    }

    if comment is not None:

        c.comment = comment

        data.update(comment.get_dict())

        data.update({'rendered_text':

                     render('changeset/changeset_comment_block.html')})

    return data

def delete_cs_pr_comment(repo_name, comment_id):

    """Delete a comment from a changeset or pull request"""

    co = db.ChangesetComment.get_or_404(comment_id)

    if co.repo.repo_name != repo_name:

        raise HTTPNotFound()

    if co.pull_request and co.pull_request.is_closed():

        # don't allow deleting comments on closed pull request

        raise HTTPForbidden()

    owner = co.author_id == request.authuser.user_id

        ChangesetCommentsModel().delete(comment=co)

        meta.Session().commit()

        return True

    else:

        raise HTTPForbidden()

class ChangesetController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(ChangesetController, self)._before(*args, **kwargs)

        c.affected_files_cut_off = 60

    def _index(self, revision, method):

        c.pull_request = None

        c.fulldiff = request.GET.get('fulldiff') # for reporting number of changed files

        # get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,

                                                             end=rev_end)

kallithea.controllers.pullrequests

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

pull requests controller for Kallithea for initializing pull requests

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 7, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

import mercurial.unionrepo

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.controllers.changeset import create_cs_pr_comment, delete_cs_pr_comment

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.utils2 import ascii_bytes, safe_bytes, safe_int

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.forms import PullRequestForm, PullRequestPostForm

from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel

log = logging.getLogger(__name__)

def _get_reviewer(user_id):

    """Look up user by ID and validate it as a potential reviewer."""

    try:

        user = db.User.get(int(user_id))

    except ValueError:

        user = None

        try:

            pull_request = cmd.execute()

            meta.Session().commit()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        h.flash(_('New pull request iteration created'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    # pullrequest_post for PR editing

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def post(self, repo_name, pull_request_id):

        pull_request = db.PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        assert pull_request.other_repo.repo_name == repo_name

        # only owner or admin can update it

        owner = pull_request.owner_id == request.authuser.user_id

            raise HTTPForbidden()

        _form = PullRequestPostForm()().to_python(request.POST)

        cur_reviewers = set(pull_request.get_reviewer_users())

        new_reviewers = set(_get_reviewer(s) for s in _form['review_members'])

        old_reviewers = set(_get_reviewer(s) for s in _form['org_review_members'])

        other_added = cur_reviewers - old_reviewers

        other_removed = old_reviewers - cur_reviewers

        if other_added:

            h.flash(_('Meanwhile, the following reviewers have been added: %s') %

                    (', '.join(u.username for u in other_added)),

                    category='warning')

        if other_removed:

            h.flash(_('Meanwhile, the following reviewers have been removed: %s') %

                    (', '.join(u.username for u in other_removed)),

                    category='warning')

        if _form['updaterev']:

            return self.create_new_iteration(pull_request,

                                      _form['updaterev'],

                                      _form['pullrequest_title'],

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.model.pull_request

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

pull request model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jun 6, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import datetime

import logging

import re

from tg import request

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.lib.hooks import log_create_pullrequest

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import ascii_bytes

from kallithea.model import db, meta

from kallithea.model.notification import NotificationModel

log = logging.getLogger(__name__)

def _assert_valid_reviewers(seq):

    """Sanity check: elements are actual User objects, and not the default user."""

    assert not any(user.is_default_user for user in seq)

class PullRequestModel(object):

    def add_reviewers(self, user, pr, reviewers, mention_recipients=None):

        """Add reviewer and send notification to them.

        """

        reviewers = set(reviewers)

        _assert_valid_reviewers(reviewers)

        if mention_recipients is not None:

        pull_request.status = db.PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

class CreatePullRequestAction(object):

    class ValidationError(Exception):

        pass

    class Empty(ValidationError):

        pass

    class AmbiguousAncestor(ValidationError):

        pass

    class Unauthorized(ValidationError):

        pass

    @staticmethod

    def is_user_authorized(org_repo, other_repo):

        """Performs authorization check with only the minimum amount of

        information needed for such a check, rather than a full command

        object.

        """

        ):

            return True

        return False

    def __init__(self, org_repo, other_repo, org_ref, other_ref, title, description, owner, reviewers):

        reviewers = set(reviewers)

        _assert_valid_reviewers(reviewers)

        (org_ref_type,

         org_ref_name,

         org_rev) = org_ref.split(':')

        org_display = h.short_ref(org_ref_type, org_ref_name)

        if org_ref_type == 'rev':

            cs = org_repo.scm_instance.get_changeset(org_rev)

            org_ref = 'branch:%s:%s' % (cs.branch, cs.raw_id)

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

        if other_ref_type == 'rev':

            cs = other_repo.scm_instance.get_changeset(other_rev)

            other_ref_name = cs.raw_id[:12]

            other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, cs.raw_id)

        )

        ChangesetStatusModel().set_status(

            self.org_repo,

            db.ChangesetStatus.STATUS_UNDER_REVIEW,

            created_by,

            comment,

            pull_request=pr,

        )

        mention_recipients = extract_mentioned_users(self.description)

        PullRequestModel().add_reviewers(created_by, pr, self.reviewers, mention_recipients)

        log_create_pullrequest(pr.get_dict(), created_by)

        return pr

class CreatePullRequestIterationAction(object):

    @staticmethod

    def is_user_authorized(old_pull_request):

        """Performs authorization check with only the minimum amount of

        information needed for such a check, rather than a full command

        object.

        """

            return True

        # Authorized to edit the old PR?

        if request.authuser.user_id != old_pull_request.owner_id:

            return False

        # Authorized to create a new PR?

        if not CreatePullRequestAction.is_user_authorized(old_pull_request.org_repo, old_pull_request.other_repo):

            return False

        return True

    def __init__(self, old_pull_request, new_org_rev, new_other_rev, title, description, owner, reviewers):

        self.old_pull_request = old_pull_request

        org_repo = old_pull_request.org_repo

        org_ref_type, org_ref_name, org_rev = old_pull_request.org_ref.split(':')

        other_repo = old_pull_request.other_repo

        other_ref_type, other_ref_name, other_rev = old_pull_request.other_ref.split(':') # other_rev is ancestor

        #assert other_ref_type == 'branch', other_ref_type # TODO: what if not?

        new_org_ref = '%s:%s:%s' % (org_ref_type, org_ref_name, new_org_rev)

        new_other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, new_other_rev)