nm.mark_all_read_for_user(self.authuser.user_id,

                                      filter_=request.GET.getall('type'))

            Session().commit()

            c.user = self.authuser

            notif = nm.query_for_user(self.authuser.user_id,

                                      filter_=request.GET.getall('type'))

            c.notifications = Page(notif, page=1, items_per_page=10)

            return render('admin/notifications/notifications_data.html')

    def update(self, notification_id):

        try:

            no = Notification.get(notification_id)

                        for un in no.notifications_to_users)

            if h.HasPermissionAny('hg.admin')() or owner:

                # deletes only notification2user

                NotificationModel().mark_read(c.authuser.user_id, no)

                Session().commit()

                return 'ok'

        except Exception:

            Session().rollback()

            log.error(traceback.format_exc())

        raise HTTPBadRequest()

    def delete(self, notification_id):

        try:

            no = Notification.get(notification_id)

                        for un in no.notifications_to_users)

            if h.HasPermissionAny('hg.admin')() or owner:

                # deletes only notification2user

                NotificationModel().delete(c.authuser.user_id, no)

                Session().commit()

                return 'ok'

        except Exception:

            Session().rollback()

            log.error(traceback.format_exc())

        raise HTTPBadRequest()

    def show(self, notification_id, format='html'):

        c.in_public_journal = UserFollowing.query() \

            .filter(UserFollowing.user_id == c.default_user_id) \

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query(sorted=True).all()

        read_access_repos = RepoList(_repos)

        c.repos_list = [(None, _('-- Not a fork --'))]

        c.repos_list += [(x.repo_id, x.repo_name)

                         for x in read_access_repos

                         if x.repo_id != c.repo_info.repo_id]

        defaults = {

        }

        c.active = 'advanced'

        if request.POST:

            raise HTTPFound(location=url('repo_edit_advanced'))

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionAnyDecorator('repository.admin')

        return data

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get_or_404(comment_id)

        if co.repo.repo_name != repo_name:

            raise HTTPNotFound()

        repo_admin = h.HasRepoPermissionAny('repository.admin')(repo_name)

        if h.HasPermissionAny('hg.admin')() or repo_admin or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

        for k, g in groupby(journal, lambda x: x.action_as_day):

            user_group = []

            #groupby username if it's a present value, else fallback to journal username

            for _unused, g2 in groupby(list(g), lambda x: x.user.username if x.user else x.username):

                l = list(g2)

                user_group.append((l[0].user, l))

            groups.append((k, user_group,))

        return groups

    def _get_journal_data(self, following_repos):

        filtering_criterion = None

        if repo_ids and user_ids:

            filtering_criterion = or_(UserLog.repository_id.in_(repo_ids),

                        UserLog.user_id.in_(user_ids))

        if repo_ids and not user_ids:

            filtering_criterion = UserLog.repository_id.in_(repo_ids)

        if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

            journal = self.sa.query(UserLog) \

            )

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        ChangesetCommentsModel().create(

            text=_('Closed, next iteration: %s .') % pull_request.url(canonical=True),

            author=c.authuser.user_id,

            pull_request=old_pull_request.pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(old_pull_request.pull_request_id)

        Session().commit()

        h.flash(_('New pull request iteration created'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    # pullrequest_post for PR editing

        h.flash(_('Pull request updated'), category='success')

        raise HTTPFound(location=pull_request.url())

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

            PullRequestModel().delete(pull_request)

            Session().commit()

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

                    category='success')

            raise HTTPFound(location=url('my_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    def show(self, repo_name, pull_request_id, extra=None):

        repo_model = RepoModel()

        if (status or close_pr or delete) and (f_path or line_no):

            # status votes and closing is only possible in general comments

            raise HTTPBadRequest()

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

        if not allowed_to_change_status:

            if status or close_pr:

                h.flash(_('No permission to change pull request status'), 'error')

                raise HTTPForbidden()

        if delete == "delete":

                h.HasPermissionAny('hg.admin')() or

                h.HasRepoPermissionAny('repository.admin')(pull_request.org_repo.repo_name) or

                h.HasRepoPermissionAny('repository.admin')(pull_request.other_repo.repo_name)

                ) and not pull_request.is_closed():

                PullRequestModel().delete(pull_request)

                Session().commit()

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

                        category='success')

                return {

                   'location': url('my_pullrequests'), # or repo pr list?

                }

                raise HTTPFound(location=url('my_pullrequests')) # or repo pr list?

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if co.pull_request.is_closed():

            #don't allow deleting comments on closed pull request

            raise HTTPForbidden()

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin')() or repo_admin or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

            self.sa.add(user_group_member)

            return user_group_member

        except Exception:

            log.error(traceback.format_exc())

            raise

    def remove_user_from_group(self, user_group, user):

        user_group = self._get_user_group(user_group)

        user = self._get_user(user)

        user_group_member = None

        for m in user_group.members:

                # Found this user's membership row

                user_group_member = m

                break

        if user_group_member:

            try:

                self.sa.delete(user_group_member)

                return True

            except Exception:

                log.error(traceback.format_exc())

                raise

        else:

          <span>

              ${h.age(co.modified_at)}

              %if co.pull_request:

                ${_('on pull request')}

                <a href="${co.pull_request.url()}">"${co.pull_request.title or _("No title")}"</a>

              %else:

                ${_('on this changeset')}

              %endif

              <a class="permalink" href="${co.url()}">&para;</a>

          </span>

            %if co.deletable():

              <div onClick="confirm('${_("Delete comment?")}') && deleteComment(${co.comment_id})" class="buttons delete-comment btn btn-mini" style="margin:0 5px">${_('Delete')}</div>

            %endif

          %endif

      </div>

      <div class="text">

        %if co.status_change:

           <div class="automatic-comment">

             <p>

               <span title="${_('Changeset status')}" class="changeset-status-lbl">${_("Status change")}: ${co.status_change[0].status_lbl}</span>

               <span class="changeset-status-ico"><i class="icon-circle changeset-status-${co.status_change[0].status}"></i></span>

             </p>

                <label for="changeset_status_unchanged">

                  ${_('No change')}

                </label>

                %for status, lbl in c.changeset_statuses:

                    <label>

                      <input type="radio" class="status_change_radio" name="changeset_status" id="${status}" value="${status}">

                      ${lbl}<i class="icon-circle changeset-status-${status}" /></i>

                    </label>

                %endfor

                %if c.pull_request is not None and ( \

                    h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) \

                <div>

                  ${_('Finish pull request')}:

                  <label>

                    <input id="save_close" type="checkbox" name="save_close">

                    ${_("Close")}

                  </label>

                  <label>

                    <input id="save_delete" type="checkbox" name="save_delete" value="delete">

                    ${_("Delete")}

                  </label>

                </div>

                %endif

        <% org_ref_name=pr.org_ref.rsplit(':', 2)[-2] %>

        <a href="${h.url('summary_home', repo_name=pr.org_repo.repo_name, anchor=org_ref_name)}">

          ${pr.org_repo.repo_name}#${org_ref_name}

        </a>

      </td>

      <td>

        <% other_ref_name=pr.other_ref.rsplit(':', 2)[-2] %>

        <a href="${h.url('summary_home', repo_name=pr.other_repo.repo_name, anchor=other_ref_name)}">

          ${pr.other_repo.repo_name}#${other_ref_name}

        </a>

      </td>

      <td style="text-align:right">

          ${h.form(url('pullrequest_delete', repo_name=pr.other_repo.repo_name, pull_request_id=pr.pull_request_id), style="display:inline-block")}

          <button class="action_button"

                  id="remove_${pr.pull_request_id}"

                  name="remove_${pr.pull_request_id}"

                  title="${_('Delete Pull Request')}"

                  onclick="return confirm('${_('Confirm to delete this pull request')}')

                      && ((${len(pr.comments)} == 0) ||

                          confirm('${_('Confirm again to delete this pull request with %s comments') % len(pr.comments)}'))

                      ">

            <i class="icon-minus-circled"></i>

          </button>

          ${h.end_form()}

    ${_('%s Pull Request %s') % (c.repo_name, c.pull_request.nice_id())}

</%block>

<%def name="breadcrumbs_links()">

    ${_('Pull request %s from %s#%s') % (c.pull_request.nice_id(), c.pull_request.org_repo.repo_name, c.cs_branch_name)}

</%def>

<%block name="header_menu">

    ${self.menu('repositories')}

</%block>

<%def name="main()">

${self.repo_context_bar('showpullrequest')}

<div class="box">

  <!-- box / title -->

  <div class="title">

    ${self.breadcrumbs()}

  </div>

  ${h.form(url('pullrequest_post', repo_name=c.repo_name, pull_request_id=c.pull_request.pull_request_id), method='post', id='pull_request_form')}

    <div class="form pr-box" style="float: left">

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

          ${_('Title')}: ${c.pull_request.title}

          %if c.pull_request.is_closed():

        u2 = User.get(self.u2)

        u3 = User.get(self.u3)

        notifications = Notification.query().all()

        assert len(notifications) == 1

        assert notifications[0].recipients == [u1, u2]

        assert notification.notification_id == notifications[0].notification_id

        unotification = UserNotification.query() \

            .filter(UserNotification.notification == notification).all()

        assert len(unotification) == len(usrs)

    def test_user_notifications(self):

        notification1 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there1',

                                            recipients=[self.u3])

        Session().commit()

        notification2 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there2',

                                            recipients=[self.u3])

        Session().commit()

        u3 = Session().query(User).get(self.u3)