specials = []

        if rev and selected is None:

            selected = 'rev:%s:%s' % (rev, rev)

            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

        # prio 3: most recent peer branch

        if peers and not selected:

            selected = peers[0][0][0]

        # prio 4: tip revision

        if not selected:

            selected = 'tag:tip:%s' % repo.tags['tip']

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (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):

        owner = self.rhodecode_user.user_id == pull_request.user_id

        reviewer = self.rhodecode_user.user_id in [x.user_id for x in

                                                   pull_request.reviewers]

        return (self.rhodecode_user.admin or owner or reviewer)

    def _load_compare_data(self, pull_request, enable_comments=True):

        """

        Load context data needed for generating compare diff

        :param pull_request:

        """

        org_repo = pull_request.org_repo

        (org_ref_type,

         org_ref_name,

         org_ref_rev) = pull_request.org_ref.split(':')

        other_repo = org_repo

        (other_ref_type,

         other_ref_name,

         other_ref_rev) = pull_request.other_ref.split(':')

        # despite opening revisions for bookmarks/branches/tags, we always

        # convert this to rev to prevent changes after bookmark or branch change

        org_ref = ('rev', org_ref_rev)

        other_ref = ('rev', other_ref_rev)

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]

        c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])

        c.org_ref = org_ref[1]

        c.org_ref_type = org_ref[0]

        c.other_ref = other_ref[1]

        c.other_ref_type = other_ref[0]

        diff_limit = self.cut_off_limit if not fulldiff else None

        # we swap org/other ref since we run a simple diff on one repo

        log.debug('running diff between %s and %s in %s'

                  % (other_ref, org_ref, org_repo.scm_instance.path))

        txtdiff = org_repo.scm_instance.get_diff(rev1=safe_str(other_ref[1]), rev2=safe_str(org_ref[1]))

        diff_processor = diffs.DiffProcessor(txtdiff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            htmldiff = diff_processor.as_html(enable_comments=enable_comments,

                                              parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], htmldiff]

    @LoginRequired()

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

                                   'repository.admin')

    def show_all(self, repo_name):

        c.repo_name = repo_name

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

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

        c.pullrequest_data = render('/pullrequests/pullrequest_data.html')

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.pullrequest_data

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

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def index(self):

        org_repo = c.rhodecode_db_repo

        if org_repo.scm_instance.alias != 'hg':

            log.error('Review not available for GIT REPOS')

            raise HTTPNotFound

        try:

            org_repo.scm_instance.get_changeset()

        except EmptyRepositoryError, e:

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

                    category='warning')

            redirect(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

        # as default for other and thus give a simple compare view

        #other_rev = request.POST.get('rev_start')

        branch = request.GET.get('branch')

        c.org_repos = []

        c.org_repos.append((org_repo.repo_name, org_repo.repo_name))

        c.default_org_repo = org_repo.repo_name

        c.org_refs, c.default_org_ref = self._get_repo_refs(org_repo.scm_instance, rev=org_rev, branch=branch)

        c.other_repos = []

        other_repos_info = {}

        def add_other_repo(repo, branch_rev=None):

            if repo.repo_name in other_repos_info: # shouldn't happen

                return

            c.other_repos.append((repo.repo_name, repo.repo_name))

            other_refs, selected_other_ref = self._get_repo_refs(repo.scm_instance, branch_rev=branch_rev)

            other_repos_info[repo.repo_name] = {

                'user': dict(user_id=repo.user.user_id,

                             username=repo.user.username,

                             firstname=repo.user.firstname,

                             lastname=repo.user.lastname,

                             gravatar_link=h.gravatar_url(repo.user.email, 14)),

                'description': repo.description.split('\n', 1)[0],

                'revs': h.select('other_ref', selected_other_ref, other_refs, class_='refs')

            }

        # add org repo to other so we can open pull request against peer branches on itself

        add_other_repo(org_repo, branch_rev=org_rev)

        c.default_other_repo = org_repo.repo_name

        # gather forks and add to this list ... even though it is rare to

        # request forks to pull from their parent

        for fork in org_repo.forks:

            add_other_repo(fork)

        # add parents of this fork also, but only if it's not empty

        if org_repo.parent and org_repo.parent.scm_instance.revisions:

            add_other_repo(org_repo.parent)

            c.default_other_repo = org_repo.parent.repo_name

        c.default_other_repo_info = other_repos_info[c.default_other_repo]

        c.other_repos_info = json.dumps(other_repos_info)

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

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            if errors.error_dict.get('revisions'):

                msg = 'Revisions: %s' % errors.error_dict['revisions']

            elif errors.error_dict.get('pullrequest_title'):

                msg = _('Pull request requires a title with min. 3 chars')

            else:

                msg = _('Error creating pull request')

            h.flash(msg, 'error')

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

"""

    rhodecode.model.pull_request

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

    pull request model for RhodeCode

    :created_on: Jun 6, 2012

    :author: marcink

    :copyright: (C) 2012-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

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

import logging

import datetime

from pylons.i18n.translation import _

from rhodecode.model.meta import Session

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

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

    ChangesetStatus

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.utils2 import safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

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

               revisions, reviewers, title, description=None):

        from rhodecode.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

        new.revisions = revisions

        new.title = title

        new.description = description

        new.author = created_by_user

        Session().add(new)

        Session().flush()

        #members

        for member in set(reviewers):

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, new)

            Session().add(reviewer)

        #reset state to under-review

        ChangesetStatusModel().set_status(

            repo=org_repo,

            status=ChangesetStatus.STATUS_UNDER_REVIEW,

            user=created_by_user,

            pull_request=new

        )

        revision_data = [(x.raw_id, x.message)

                         for x in map(org_repo.get_changeset, revisions)]

        #notification to reviewers

        pr_url = h.url('pullrequest_show', repo_name=other_repo.repo_name,

                       pull_request_id=new.pull_request_id,

                       qualified=True,

        )

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request #%(pr_id)s: %(pr_title)s') % \

                {'user': created_by_user.username,

                 'pr_title': new.title,

                 'pr_id': new.pull_request_id},

                pr_url

            )

        )

        body = description

        kwargs = {

            'pr_title': title,

            'pr_user_created': h.person(created_by_user.email),

            'pr_repo_url': h.url('summary_home', repo_name=other_repo.repo_name,

                                 qualified=True,),

            'pr_url': pr_url,

            'pr_revisions': revision_data

        }

        NotificationModel().create(created_by=created_by_user, subject=subject, body=body,

                                   recipients=reviewers,

                                   type_=Notification.TYPE_PULL_REQUEST, email_kwargs=kwargs)

        return new

    def update_reviewers(self, pull_request, reviewers_ids):

        reviewers_ids = set(reviewers_ids)

        pull_request = self.__get_pull_request(pull_request)

        current_reviewers = PullRequestReviewers.query()\

                            .filter(PullRequestReviewers.pull_request==

                                   pull_request)\

                            .all()

        current_reviewers_ids = set([x.user.user_id for x in current_reviewers])

        to_add = reviewers_ids.difference(current_reviewers_ids)

        to_remove = current_reviewers_ids.difference(reviewers_ids)

        log.debug("Adding %s reviewers" % to_add)

        log.debug("Removing %s reviewers" % to_remove)

        for uid in to_add:

            _usr = self._get_user(uid)

            reviewer = PullRequestReviewers(_usr, pull_request)

            Session().add(reviewer)

        for uid in to_remove:

            reviewer = PullRequestReviewers.query()\

                    .filter(PullRequestReviewers.user_id==uid,

                            PullRequestReviewers.pull_request==pull_request)\

                    .scalar()

            if reviewer:

                Session().delete(reviewer)

    def delete(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        Session().delete(pull_request)

</%def>

<%def name="admin_menu()">

  <ul class="admin_menu">

      <li>${h.link_to(_('Admin journal'),h.url('admin_home'),class_='journal ')}</li>

      <li>${h.link_to(_('Repositories'),h.url('repos'),class_='repos')}</li>

      <li>${h.link_to(_('Repository groups'),h.url('repos_groups'),class_='repos_groups')}</li>

      <li>${h.link_to(_('Users'),h.url('users'),class_='users')}</li>

      <li>${h.link_to(_('User groups'),h.url('users_groups'),class_='groups')}</li>

      <li>${h.link_to(_('Permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>

      <li>${h.link_to(_('LDAP'),h.url('ldap_home'),class_='ldap')}</li>

      <li>${h.link_to(_('Defaults'),h.url('defaults'),class_='defaults')}</li>

      <li class="last">${h.link_to(_('Settings'),h.url('admin_settings'),class_='settings')}</li>

  </ul>

</%def>

<%def name="admin_menu_simple(repositories=None, repository_groups=None, user_groups=None)">

  <ul>

   %if repositories:

      <li>${h.link_to(_('Repositories'),h.url('repos'),class_='repos')}</li>

   %endif

   %if repository_groups:

      <li>${h.link_to(_('Repository groups'),h.url('repos_groups'),class_='repos_groups')}</li>

   %endif

   %if user_groups:

      <li>${h.link_to(_('User groups'),h.url('users_groups'),class_='groups')}</li>

   %endif

  </ul>

</%def>

<%def name="repo_context_bar(current=None)">

  <%

      def follow_class():

          if c.repository_following:

              return h.literal('following')

          else:

              return h.literal('follow')

  %>

  <%

    def is_current(selected):

        if selected == current:

            return h.literal('class="current"')

    %>

  <!--- CONTEXT BAR -->

  <div id="context-bar" class="box">

      <div id="breadcrumbs">

        ${h.link_to(_(u'Repositories'),h.url('home'))}

        »

        ${h.repo_link(c.rhodecode_db_repo.groups_and_repo)}

      </div>

      <ul id="context-pages" class="horizontal-list">

        <li ${is_current('summary')}><a href="${h.url('summary_home', repo_name=c.repo_name)}" class="summary">${_('Summary')}</a></li>

        <li ${is_current('changelog')}><a href="${h.url('changelog_home', repo_name=c.repo_name)}" class="changelogs">${_('Changelog')}</a></li>

        <li ${is_current('files')}><a href="${h.url('files_home', repo_name=c.repo_name)}" class="files"></span>${_('Files')}</a></li>

        <li ${is_current('switch-to')}>

          <a href="#" id="branch_tag_switcher_2" class="dropdown switch-to"></span>${_('Switch To')}</a>

          <ul id="switch_to_list_2" class="switch_to submenu">

            <li><a href="#">${_('Loading...')}</a></li>

          </ul>

        </li>

        <li ${is_current('options')}>

          <a href="#" class="dropdown options"></span>${_('Options')}</a>

          <ul>

             %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):

                   <li>${h.link_to(_('Settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>

             %endif

              %if c.rhodecode_db_repo.fork:

               <li>${h.link_to(_('Compare fork'),h.url('compare_url',repo_name=c.rhodecode_db_repo.fork.repo_name,org_ref_type='branch',org_ref='default',other_repo=c.repo_name,other_ref_type='branch',other_ref=request.GET.get('branch') or 'default', merge=1),class_='compare_request')}</li>

              %endif

              <li>${h.link_to(_('Search'),h.url('search_repo',repo_name=c.repo_name),class_='search')}</li>

              %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking:

                %if c.rhodecode_db_repo.locked[0]:

                  <li>${h.link_to(_('Unlock'), h.url('toggle_locking',repo_name=c.repo_name),class_='locking_del')}</li>

                %else:

                  <li>${h.link_to(_('Lock'), h.url('toggle_locking',repo_name=c.repo_name),class_='locking_add')}</li>

                %endif

              %endif

              ## TODO: this check feels wrong, it would be better to have a check for permissions

              ## also it feels like a job for the controller

              %if c.rhodecode_user.username != 'default':

                  <li>

                   <a class="${follow_class()}" onclick="javascript:toggleFollowingRepo(this,${c.rhodecode_db_repo.repo_id},'${str(h.get_token())}');">

                    <span class="show-follow">${_('Follow')}</span>

                    <span class="show-following">${_('Unfollow')}</span>

                  </a>

                  </li>

                  <li><a href="${h.url('repo_fork_home',repo_name=c.repo_name)}" class="fork">${_('Fork')}</a></li>

                  %if h.is_hg(c.rhodecode_repo):

                  <li><a href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="pull-request">${_('Create Pull Request')}</a></li>

                  %endif

              %endif

             </ul>

        </li>

        <li ${is_current('showpullrequest')}>

            %if c.repository_pull_requests:

              <span>${c.repository_pull_requests}</span>

            %endif

          </a>

        </li>

      </ul>

  </div>

  <script type="text/javascript">

      YUE.on('branch_tag_switcher_2','mouseover',function(){

         var loaded = YUD.hasClass('branch_tag_switcher_2','loaded');

         if(!loaded){

             YUD.addClass('branch_tag_switcher_2','loaded');

             ypjax("${h.url('branch_tag_switcher',repo_name=c.repo_name)}",'switch_to_list_2',

                 function(o){},

                 function(o){YUD.removeClass('branch_tag_switcher_2','loaded');}

                 ,null);

         }

         return false;

      });

  </script>

  <!--- END CONTEXT BAR -->

</%def>

<%def name="usermenu()">

    ## USER MENU

    <li>

      <a class="menu_link childs" id="quick_login_link">

          <span class="icon">

             <img src="${h.gravatar_url(c.rhodecode_user.email,20)}" alt="avatar">

          </span>

          %if c.rhodecode_user.username != 'default':

            <span class="menu_link_user">${c.rhodecode_user.username}</span>

            %if c.unread_notifications != 0:

              <span class="menu_link_notifications">${c.unread_notifications}</span>

            %endif

          %else:

              <span>${_('Not logged in')}</span>

          %endif

      </a>

  <div class="user-menu">

      <div id="quick_login">

        %if c.rhodecode_user.username == 'default':

            <h4>${_('Login to your account')}</h4>

            ${h.form(h.url('login_home',came_from=h.url.current()))}

            <div class="form">

                <div class="fields">

                    <div class="field">

                        <div class="label">

                            <label for="username">${_('Username')}:</label>

                        </div>

                        <div class="input">

                            ${h.text('username',class_='focus')}

                        </div>

                    </div>

                    <div class="field">

                        <div class="label">

                            <label for="password">${_('Password')}:</label>

                        </div>

                        <div class="input">

                            ${h.password('password',class_='focus')}

                        </div>

                    </div>

                    <div class="buttons">

                        <div class="password_forgoten">${h.link_to(_('Forgot password ?'),h.url('reset_password'))}</div>

                        <div class="register">

                        %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():

                         ${h.link_to(_("Don't have an account ?"),h.url('register'))}

                        %endif

                        </div>

                        <div class="submit">

                            ${h.submit('sign_in',_('Log In'),class_="ui-btn xsmall")}

                        </div>

                    </div>

                </div>

            </div>

            ${h.end_form()}

        %else:

            <div class="links_left">

                <div class="big_gravatar"><img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,48)}" /></div>

                <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>

                <div class="email">${c.rhodecode_user.email}</div>

            </div>

            <div class="links_right">

            <ol class="links">

              <li><a href="${h.url('notifications')}">${_('Notifications')}: ${c.unread_notifications}</a></li>

              <li>${h.link_to(_(u'My account'),h.url('admin_settings_my_account'))}</li>

              <li class="logout">${h.link_to(_(u'Log Out'),h.url('logout_home'))}</li>

            </ol>

            </div>

        %endif

      </div>

  </div>

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

% for pr in c.pullrequests_pager:

  <div class="pr ${'pr-closed' if pr.is_closed() else ''}">

    <div class="pr-title">

      <img src="${h.url('/images/icons/flag_status_%s.png' % str(pr.last_review_status))}" />

      ${_('Pull request #%s opened by %s on %s') % (pr.pull_request_id, pr.author.full_name, h.fmt_date(pr.created_on))}

      </a>

       %if pr.is_closed():

         <span class="pr-closed-tag">${_('Closed')}</span>

       %endif

    </div>

    <h5 style="border:0px;padding-bottom:0px">${_('Title')}: ${pr.title}</h5>

    <div class="pr-desc">${pr.description}</div>

  </div>

% endfor

<div class="notification-paginator">

  <div class="pagination-wh pagination-left">

  ${c.pullrequests_pager.pager('$link_previous ~2~ $link_next')}

  </div>

</div>

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('%s Pull Requests') % c.repo_name} · ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

</%def>

<%def name="page_nav()">

    ${self.menu('repositories')}

</%def>

<%def name="main()">

${self.repo_context_bar('showpullrequest')}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    ${c.pullrequest_data}

</div>

</%def>