def index(self, org_ref_type, org_ref, other_ref_type, other_ref):

        org_repo = c.rhodecode_db_repo.repo_name

        org_ref = (org_ref_type, org_ref)

        other_ref = (other_ref_type, other_ref)

        other_repo = request.GET.get('other_repo', org_repo)

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

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

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

        c.swap_url = h.url('compare_url', as_form=request.GET.get('as_form'),

            repo_name=other_repo,

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

            other_repo=org_repo,

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

        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:

            log.error('Could not find org repo %s' % org_repo)

            raise HTTPNotFound

        if c.other_repo is None:

            log.error('Could not find other repo %s' % other_repo)

            raise HTTPNotFound

        if c.org_repo != c.other_repo and h.is_git(c.rhodecode_repo):

            log.error('compare of two remote repos not available for GIT REPOS')

            raise HTTPNotFound

        if c.org_repo.scm_instance.alias != c.other_repo.scm_instance.alias:

            log.error('compare of two different kind of remote repos not available')

            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)

        if rev_start and rev_end:

            #replace our org_ref with given CS

            org_ref = ('rev', rev_start)

            other_ref = ('rev', rev_end)

        c.cs_ranges, ancestor = 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])

        # defines that we need hidden inputs with changesets

        c.as_form = request.GET.get('as_form', False)

        if partial:

            return render('compare/compare_cs.html')

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        if ancestor  and c.org_repo != c.other_repo:

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the forked repo, with

            # revision that is common ancestor

            _org_ref = org_ref

            log.debug('Using ancestor %s as org_ref instead of %s', ancestor, _org_ref)

            org_ref = ('rev', ancestor)

            org_repo = other_repo

        diff_limit = self.cut_off_limit if not fulldiff else None

        _diff = diffs.differ(org_repo, org_ref, other_repo, other_ref)

        diff_processor = diffs.DiffProcessor(_diff 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']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

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

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

            diff = diff_processor.as_html(enable_comments=False, parsed_lines=[f])

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

        return render('compare/compare_diff.html')

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.rhodecode_user.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

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

                    category='success')

            return redirect(url('admin_settings_my_account', anchor='pullrequests'))

        raise HTTPForbidden()

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

        """

        Load context data needed for generating compare diff

        :param pull_request:

        :type pull_request:

        """

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

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

        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 book 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]

        other_ref = ('rev', getattr(c.cs_ranges[0].parents[0]

                                  if c.cs_ranges[0].parents

                                  else EmptyChangeset(), 'raw_id'))

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

        # defines that we need hidden inputs with changesets

        c.as_form = request.GET.get('as_form', False)

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        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

        _diff = diffs.differ(org_repo, other_ref, other_repo, org_ref)

        diff_processor = diffs.DiffProcessor(_diff 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']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

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

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

            diff = diff_processor.as_html(enable_comments=enable_comments,

                                          parsed_lines=[f])

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

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

## Changesets table !

<div class="container">

  <table class="compare_view_commits noborder">

  %if not c.cs_ranges:

    <span class="empty_data">${_('No changesets')}</span>

  %else:

    %for cnt, cs in enumerate(c.cs_ranges):

        <tr>

        <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),14)}"/></div></td>

        <td>

          %if cs.raw_id in c.statuses:

            <div title="${c.statuses[cs.raw_id][1]}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cs.raw_id][0])}" /></div>

          %endif

        </td>

        %if c.as_form:

          ${h.hidden('revisions',cs.raw_id)}

        %endif

        </td>

        <td><div class="author">${h.person(cs.author)}</div></td>

        <td><span class="tooltip" title="${h.tooltip(h.age(cs.date))}">${cs.date}</span></td>

        <td><div class="message tooltip" title="${h.tooltip(cs.message)}" style="white-space:normal">${h.urlify_commit(h.shorter(cs.message, 60),c.repo_name)}</div></td>

        </tr>

    %endfor

  %endif

  </table>

</div>