org_ref_type=other_ref[0], org_ref=other_ref[1],

              other_ref_type=org_ref[0], other_ref=org_ref[1],

              repo=org_repo, as_form=request.GET.get('as_form'),

              bundle=bundle_compare)

        c.org_repo = org_repo = Repository.get_by_repo_name(org_repo)

        c.other_repo = other_repo = Repository.get_by_repo_name(other_repo)

        if c.org_repo is None or c.other_repo is None:

            log.error('Could not found repo %s or %s' % (org_repo, other_repo))

            raise HTTPNotFound

            raise HTTPNotFound

        partial = request.environ.get('HTTP_X_PARTIAL_XHR')

        self.__get_cs_or_redirect(rev=org_ref, repo=org_repo, partial=partial)

        self.__get_cs_or_redirect(rev=other_ref, repo=other_repo, partial=partial)

        c.cs_ranges, discovery_data = PullRequestModel().get_compare_data(

                                    org_repo, org_ref, other_repo, other_ref

                                    )

        c.statuses = c.rhodecode_db_repo.statuses([x.raw_id for x in

                                                   c.cs_ranges])

        c.target_repo = c.repo_name

        # defines that we need hidden inputs with changesets

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        return defaults

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

                                   'repository.admin')

    def forks(self, repo_name):

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

        repo_id = c.rhodecode_db_repo.repo_id

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(r.repo_name, 'get forks check'):

    :type org_repo:

    :param org_ref:

    :type org_ref:

    :param other_repo:

    :type other_repo:

    :param other_ref:

    :type other_ref:

    """

    bundlerepo = None

    ignore_whitespace = ignore_whitespace

    context = context

    other_repo = other_repo.scm_instance._repo

    opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)

    org_ref = org_ref[1]

    other_ref = other_ref[1]

        common, incoming, rheads = discovery_data

        other_repo_peer = localrepo.locallegacypeer(other_repo.local())

        # create a bundle (uncompressed if other repo is not local)

        if other_repo_peer.capable('getbundle') and incoming:

            # disable repo hooks here since it's just bundle !

            # patch and reset hooks section of UI config to not run any

            # hooks on fetching archives with subrepos

            for k, _ in other_repo.ui.configitems('hooks'):

                other_repo.ui.setconfig('hooks', k, None)

            unbundle = other_repo.getbundle('incoming', common=common,

            buf.seek(0)

            # replace chunked _stream with data that can do tell() and seek()

            unbundle._stream = buf

            ui = make_ui('db')

            bundlerepo = InMemoryBundleRepo(ui, path=org_repo.root,

                                            bundlestream=unbundle)

        return ''.join(patch.diff(bundlerepo or org_repo,

                                  node1=org_repo[org_ref].node(),

                                  node2=other_repo[other_ref].node(),

                                  opts=opts))

#

# 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 binascii

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

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.vcs.utils.hgcompat import discovery, localrepo, scmutil, \

    findcommonoutgoing

                self.sa.delete(reviewer)

    def delete(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        Session().delete(pull_request)

    def close_pull_request(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

        self.sa.add(pull_request)

                        discovery_data):

        """

        Returns a list of changesets that are incoming from org_repo@org_ref

        to other_repo@other_ref

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        changesets = []

        #case two independent repos

        common, incoming, rheads = discovery_data

        if org_repo != other_repo and incoming:

            obj = findcommonoutgoing(org_repo._repo,

                        localrepo.locallegacypeer(other_repo._repo.local()),

                        force=True)

            revs = obj.missing

            for cs in reversed(map(binascii.hexlify, revs)):

                changesets.append(org_repo.get_changeset(cs))

        else:

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            revs = [

                "ancestors(%s('%s')) and not ancestors(%s('%s'))" % (

                    _revset_predicates[org_ref[0]], org_ref[1],

                    _revset_predicates[other_ref[0]], other_ref[1]

               )

            ]

            out = scmutil.revrange(org_repo._repo, revs)

            for cs in reversed(out):

                changesets.append(org_repo.get_changeset(cs))

        return changesets

    def _get_discovery(self, org_repo, org_ref, other_repo, other_ref):

        """

        Get's mercurial discovery data used to calculate difference between

        repos and refs

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        org_peer = localrepo.locallegacypeer(_org_repo.local())

        tmp = discovery.findcommonincoming(

                  repo=_other_repo,  # other_repo we check for incoming

                  remote=org_peer,  # org_repo source for incoming

                  heads=[_other_repo[other_rev].node(),

                         _org_repo[org_rev].node()],

                  force=True

        )

        return tmp

    def get_compare_data(self, org_repo, org_ref, other_repo, other_ref):

        """

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        """

        if len(org_ref) != 2 or not isinstance(org_ref, (list, tuple)):

            raise Exception('org_ref must be a two element list/tuple')

        if len(other_ref) != 2 or not isinstance(org_ref, (list, tuple)):

            raise Exception('other_ref must be a two element list/tuple')

                                         discovery_data)

        return cs_ranges, discovery_data

<script type="text/javascript">

YUE.on('compare_branches','click',function(e){

	YUE.preventDefault(e);

	var org = YUQ('input[name=compare_org]:checked')[0];

	var other = YUQ('input[name=compare_other]:checked')[0];

	if(org && other){

	    var compare_url = "${h.url('compare_url',repo_name=c.repo_name,org_ref_type='branch',org_ref='__ORG__',other_ref_type='branch',other_ref='__OTHER__')}";

		var u = compare_url.replace('__ORG__',org.value)

		                   .replace('__OTHER__',other.value);

		window.location=u;

	}

// main table sorting

var myColumnDefs = [

    {key:"name",label:"${_('Name')}",sortable:true},

    {key:"date",label:"${_('Date')}",sortable:true,

        sortOptions: { sortFunction: dateSort }},

    {key:"author",label:"${_('Author')}",sortable:true},

    {key:"revision",label:"${_('Revision')}",sortable:true,

        sortOptions: { sortFunction: revisionSort }},

    {key:"compare",label:"${_('Compare')}",sortable:false,},

];

var myDataSource = new YAHOO.util.DataSource(YUD.get("branches_data"));

%if c.repo_branches:

   <div id="table_wrap" class="yui-skin-sam">

    <table id="branches_data">

      <thead>

        <tr>

        </tr>

      </thead>

		%for cnt,branch in enumerate(c.repo_branches.items()):

		<tr class="parity${cnt%2}">

            <td>

                <span class="logtags">

                    <span class="branchtag">${h.link_to(branch[0],

                    h.url('files_home',repo_name=c.repo_name,revision=branch[1].raw_id))}</span>

                </span>

            </td>

            <td><span class="tooltip" title="${h.tooltip(h.age(branch[1].date))}">${h.fmt_date(branch[1].date)}</span></td>

            <td title="${branch[1].author}">${h.person(branch[1].author)}</td>

    <div class="table">

		% if c.pagination:

			<div id="graph">

				<div id="graph_nodes">

					<canvas id="graph_canvas"></canvas>

				</div>

				<div id="graph_content">

                    <div class="info_box" style="clear: both;padding: 10px 6px;vertical-align: right;text-align: right;">

                    <a href="#" class="ui-btn small" id="rev_range_container" style="display:none"></a>

                    <a href="#" class="ui-btn small" id="rev_range_clear" style="display:none">${_('Clear selection')}</a>

                    %if c.rhodecode_db_repo.fork:

                    %endif

                    %if h.is_hg(c.rhodecode_repo):

                    <a id="open_new_pr" href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="ui-btn small">${_('Open new pull request')}</a>

                    %endif

                    </div>

					<div class="container_header">

				        ${h.form(h.url.current(),method='get')}

				        <div class="info_box" style="float:left">

				          ${h.submit('set',_('Show'),class_="ui-btn")}

				          ${h.text('size',size=1,value=c.size)}

				          ${_('revisions')}

				        </div>

</%def>

<%def name="page_nav()">

    ${self.menu('tags')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <!-- end box / title -->

    <div class="table">

        <%include file='tags_data.html'/>

    </div>

</div>

<script type="text/javascript">

// main table sorting

var myColumnDefs = [

    {key:"name",label:"${_('Name')}",sortable:true},

    {key:"date",label:"${_('Date')}",sortable:true,

        sortOptions: { sortFunction: dateSort }},

    {key:"author",label:"${_('Author')}",sortable:true},

    {key:"revision",label:"${_('Revision')}",sortable:true,

        sortOptions: { sortFunction: revisionSort }},

];

var myDataSource = new YAHOO.util.DataSource(YUD.get("tags_data"));

myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;

myDataSource.responseSchema = {

    fields: [

        {key:"name"},

        {key:"date"},

        {key:"author"},

        {key:"revision"},

    ]

};

var myDataTable = new YAHOO.widget.DataTable("table_wrap", myColumnDefs, myDataSource,

        {

         sortedBy:{key:"name",dir:"asc"},

         MSG_SORTASC:"${_('Click to sort ascending')}",

         MSG_SORTDESC:"${_('Click to sort descending')}",

         MSG_EMPTY:"${_('No records found.')}",

         MSG_ERROR:"${_('Data error.')}",

         MSG_LOADING:"${_('Loading...')}",

        }

%if c.repo_tags:

   <div id="table_wrap" class="yui-skin-sam">

    <table id="tags_data">

      <thead>

    	<tr>

            <th class="left">${_('Name')}</th>

            <th class="left">${_('Date')}</th>

            <th class="left">${_('Author')}</th>

            <th class="left">${_('Revision')}</th>

    	</tr>

      </thead>

		%for cnt,tag in enumerate(c.repo_tags.items()):

		<tr class="parity${cnt%2}">

            <td>

                <span class="logtags">

                    <span class="tagtag">${h.link_to(tag[0],

                    h.url('files_home',repo_name=c.repo_name,revision=tag[1].raw_id))}

                    </span>

                </span>

            </td>

            <td><span class="tooltip" title="${h.tooltip(h.age(tag[1].date))}">${h.fmt_date(tag[1].date)}</span></td>

	        <td title="${tag[1].author}">${h.person(tag[1].author)}</td>

	        <td>

                <div>

                    <pre><a href="${h.url('files_home',repo_name=c.repo_name,revision=tag[1].raw_id)}">r${tag[1].revision}:${h.short_id(tag[1].raw_id)}</a></pre>

                </div>

            </td>

		</tr>

		%endfor

    </table>

   </div>

%else:

	${_('There are no tags yet')}

%endif