(bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _get_is_allowed_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        owner = self.authuser.user_id == pull_request.user_id

        reviewer = PullRequestReviewers.query() \

            .filter(PullRequestReviewers.pull_request == pull_request) \

            .filter(PullRequestReviewers.user_id == self.authuser.user_id) \

            .count() != 0

        return self.authuser.admin or owner or reviewer

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def show_all(self, repo_name):

        c.from_ = request.GET.get('from_') or ''

        c.closed = request.GET.get('closed') or ''

        p = safe_int(request.GET.get('page'), 1)

        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100)

        return render('/pullrequests/pullrequest_show_all.html')

    @LoginRequired()

    @NotAnonymous()

    def show_my(self):

        c.closed = request.GET.get('closed') or ''

        c.participate_in_pull_requests = []

        c.participate_in_pull_requests_todo = []

        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

            status = pr.user_review_status(c.authuser.user_id) # very inefficient!!!

            if status in done_status:

                c.participate_in_pull_requests.append(pr)

            else:

                c.participate_in_pull_requests_todo.append(pr)

        return render('/pullrequests/pullrequest_show_my.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self):

        org_repo = c.db_repo

        org_scm_instance = org_repo.scm_instance

        try:

            org_scm_instance.get_changeset()

        except EmptyRepositoryError as e:

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            raise HTTPFound(location=url('summary_home', repo_name=org_repo.repo_name))

        org_rev = request.GET.get('rev_end')

        # rev_start is not directly useful - its parent could however be used

import traceback

import webob.exc

import paste.httpexceptions

import paste.auth.basic

import paste.httpheaders

from pylons import config, tmpl_context as c, request, session

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render  # don't remove this import

from pylons.i18n.translation import _

from kallithea import __version__, BACKENDS

from kallithea.config.routing import url

from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \

    safe_str, safe_int

from kallithea.lib import auth_modules

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.utils import get_repo_slug

from kallithea.lib.exceptions import UserCreationError

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

from kallithea.model import meta

from kallithea.model.notification import NotificationModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

def _filter_proxy(ip):

    """

    HEADERS can have multiple ips inside the left-most being the original

    client, and each successive proxy that passed the request adding the IP

    address where it received the request from.

    :param ip:

    """

    if ',' in ip:

        _ips = ip.split(',')

        _first_ip = _ips[0].strip()

        log.debug('Got multiple IPs %s, using %s', ','.join(_ips), _first_ip)

        return _first_ip

    return ip

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

                (function() {

                    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;

                    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

                    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);

                    })();

            </script>''' % c.ga_code

        c.site_name = rc_config.get('title')

        c.clone_uri_tmpl = rc_config.get('clone_uri_tmpl')

        ## INI stored

        c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))

        c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))

        c.instance_id = config.get('instance_id')

        c.issues_url = config.get('bugtracker', url('issues_url'))

        # END CONFIG VARS

        c.repo_name = get_repo_slug(request)  # can be empty

        c.backends = BACKENDS.keys()

        c.unread_notifications = NotificationModel() \

                        .get_unread_cnt_for_user(c.authuser.user_id)

        self.cut_off_limit = safe_int(config.get('cut_off_limit'))

        self.sa = meta.Session

        self.scm_model = ScmModel(self.sa)

    @staticmethod

    def _determine_auth_user(api_key, session_authuser):

        """

        Create an `AuthUser` object given the API key (if any) and the

        value of the authuser session cookie.

        """

        # Authenticate by API key

        if api_key:

            # when using API_KEY we are sure user exists.

            return AuthUser(dbuser=User.get_by_api_key(api_key),

                            is_external_auth=True)

        # Authenticate by session cookie

        # In ancient login sessions, 'authuser' may not be a dict.

        # In that case, the user will have to log in again.

        # v0.3 and earlier included an 'is_authenticated' key; if present,

        # this must be True.

        if isinstance(session_authuser, dict) and session_authuser.get('is_authenticated', True):

            try:

    def revisions(self):

        return self._revisions.split(':')

    @revisions.setter

    def revisions(self, val):

        self._revisions = safe_unicode(':'.join(val))

    @property

    def org_ref_parts(self):

        return self.org_ref.split(':')

    @property

    def other_ref_parts(self):

        return self.other_ref.split(':')

    owner = relationship('User')

    reviewers = relationship('PullRequestReviewers',

                             cascade="all, delete-orphan")

    org_repo = relationship('Repository', primaryjoin='PullRequest.org_repo_id==Repository.repo_id')

    other_repo = relationship('Repository', primaryjoin='PullRequest.other_repo_id==Repository.repo_id')

    statuses = relationship('ChangesetStatus', order_by='ChangesetStatus.changeset_status_id')

    comments = relationship('ChangesetComment', order_by='ChangesetComment.comment_id',

                             cascade="all, delete-orphan")

    def get_reviewer_users(self):

        """Like .reviewers, but actually returning the users"""

        return User.query() \

            .join(PullRequestReviewers) \

            .filter(PullRequestReviewers.pull_request == self) \

            .order_by(PullRequestReviewers.pull_requests_reviewers_id) \

            .all()

    def is_closed(self):

        return self.status == self.STATUS_CLOSED

    def user_review_status(self, user_id):

        """Return the user's latest status votes on PR"""

        # note: no filtering on repo - that would be redundant

        status = ChangesetStatus.query() \

            .filter(ChangesetStatus.pull_request == self) \

            .filter(ChangesetStatus.user_id == user_id) \

            .order_by(ChangesetStatus.version) \

            .first()

        return str(status.status) if status else ''

    @classmethod

    def make_nice_id(cls, pull_request_id):

        '''Return pull request id nicely formatted for displaying'''

"""

import logging

import datetime

from pylons.i18n.translation import _

from sqlalchemy.orm import joinedload

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserInvalidException

from kallithea.model import BaseModel

from kallithea.model.db import PullRequest, PullRequestReviewers, Notification, \

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    def _get_valid_reviewers(self, seq):

        """ Generate User objects from a sequence of user IDs, usernames or

        User objects. Raises UserInvalidException if the DEFAULT user is

        specified, or if a given ID or username does not match any user.

        """

        for user_spec in seq:

            user = self._get_user(user_spec)

            if user is None or user.username == User.DEFAULT_USER:

                raise UserInvalidException(user_spec)

            yield user

    def create(self, created_by, org_repo, org_ref, other_repo, other_ref,

               revisions, reviewers, title, description=None):

        from kallithea.model.changeset_status import ChangesetStatusModel

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        other_repo = self._get_repo(other_repo)

        new = PullRequest()

        new.org_repo = org_repo

        new.org_ref = org_ref

        new.other_repo = other_repo

        new.other_ref = other_ref