reviewer = PullRequestReviewers.query()\

                    .filter(PullRequestReviewers.user_id==uid,

                            PullRequestReviewers.pull_request==pull_request)\

                    .scalar()

            if reviewer:

                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)

    def _get_changesets(self, alias, org_repo, org_ref, other_repo, other_ref,

                        discovery_data):

        """

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

        to other_repo@other_ref

        :param org_repo:

        :param org_ref:

        :param other_repo:

        :param other_ref:

        :param tmp:

        """

        changesets = []

        #case two independent repos

        common, incoming, rheads = discovery_data

        if org_repo != other_repo:

            revs = [

                org_repo._repo.lookup(org_ref[1]),

                org_repo._repo.lookup(other_ref[1]),

            ]

            obj = findcommonoutgoing(org_repo._repo,

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

                        revs,

                        force=True)

            revs = obj.missing

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

                _cs = org_repo.get_changeset(cs)

                changesets.append(_cs)

        else:

            #no remote compare do it on the same repository

            if alias == 'hg':

                _revset_predicates = {

                        'branch': 'branch',

                        'book': 'bookmark',

                        'tag': 'tag',

                        'rev': 'id',

                    }

                revs = [

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

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

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

                   )

                ]

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

                for cs in (out):

                    changesets.append(org_repo.get_changeset(cs))

            elif alias == 'git':

                so, se = org_repo.run_git_command(

                    'log --reverse --pretty="format: %%H" -s -p %s..%s' % (org_ref[1],

                                                                     other_ref[1])

                )

                ids = re.findall(r'[0-9a-fA-F]{40}', so)

                for cs in (ids):

                    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:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        """

        _org_repo = org_repo._repo

        org_rev_type, org_rev = org_ref

        log.debug('Doing discovery for %s@%s vs %s@%s' % (

                        org_repo, org_ref, other_repo, other_ref)

        )

        #log.debug('Filter heads are %s[%s]' % ('', org_ref[1]))

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

        """

        Returns a tuple of incomming changesets, and discoverydata cache for

        mercurial repositories

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

        org_repo_scm = org_repo.scm_instance

        other_repo_scm = other_repo.scm_instance

        alias = org_repo.scm_instance.alias

        discovery_data = [None, None, None]

        if alias == 'hg':

            discovery_data = self._get_discovery(org_repo_scm, org_ref,

                                               other_repo_scm, other_ref)

        cs_ranges = self._get_changesets(alias,

                                         org_repo_scm, org_ref,

                                         other_repo_scm, other_ref,

                                         discovery_data)

        return cs_ranges, discovery_data

                                    %if h.is_hg(c.rhodecode_repo):

                                      %for book in cs.bookmarks:

                                      <span class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">

                                         ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}

                                      </span>

                                      %endfor

                                    %endif

									%for tag in cs.tags:

										<span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">

										${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>

									%endfor

								</span>

						</div>

					</div>

				%endfor

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

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

				</div>

				</div>

			</div>

			<script type="text/javascript" src="${h.url('/js/graph.js')}"></script>

			<script type="text/javascript">

				YAHOO.util.Event.onDOMReady(function(){

                    //Monitor range checkboxes and build a link to changesets

                    //ranges

                    var checkboxes = YUD.getElementsByClassName('changeset_range');

                    var url_tmpl = "${h.url('changeset_home',repo_name=c.repo_name,revision='__REVRANGE__')}";

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

                    	var clicked_cb = e.currentTarget;

                        var checked_checkboxes = [];

                        for (pos in checkboxes){

                            if(checkboxes[pos].checked){

                                checked_checkboxes.push(checkboxes[pos]);

                            }

                        }

                        if(YUD.get('open_new_pr')){

                          if(checked_checkboxes.length>0){

                            // modify open pull request to show we have selected cs

                            YUD.get('open_new_pr').innerHTML = _TM['Open new pull request for selected changesets'];

                          }else{

                            YUD.get('open_new_pr').innerHTML = _TM['Open new pull request'];

                          }

                        }

                        	var rev_end = checked_checkboxes[0].name;

                        	var rev_start = checked_checkboxes[checked_checkboxes.length-1].name;

                        	// now select all checkboxes in the middle.

                        	var checked = false;

                        	for (var i=0; i<checkboxes.length; i++){

                        		var cb = checkboxes[i];

                        		var rev = cb.name;

                        		if (rev == rev_end){

                        			checked = true;

                        		}

                                if (checked){

                                    cb.checked = true;

                                }

                                else{

                                    cb.checked = false;

                                }

                        		if (rev == rev_start){

                                    checked = false;

                                }

                        	}

                            var url = url_tmpl.replace('__REVRANGE__',

                            		rev_start+'...'+rev_end);

                            var link = _TM['Show selected changes __S -> __E'];

                            link = link.replace('__S',rev_start.substr(0,6));

                            link = link.replace('__E',rev_end.substr(0,6));

                            YUD.get('rev_range_container').href = url;

                            YUD.get('rev_range_container').innerHTML = link;

                            YUD.setStyle('rev_range_container','display','');

                            YUD.setStyle('rev_range_clear','display','');

                            YUD.get('open_new_pr').href += '?rev_start={0}&rev_end={1}'.format(rev_start,rev_end);

                        }

                        else{

                        	YUD.setStyle('rev_range_container','display','none');

                        	YUD.setStyle('rev_range_clear','display','none');

                        }

                    });

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

                        for (var i=0; i<checkboxes.length; i++){

                            var cb = checkboxes[i];

                            cb.checked = false;

                        }