m.connect("admin_settings_notifications", "/notifications",

                  action="notifications", conditions=dict(method=["GET"]))

from rhodecode.model.notification import NotificationModel

    @NotAnonymous()

    def notifications(self):

        c.user = User.get(self.rhodecode_user.user_id)

        c.notifications = NotificationModel().get_for_user(c.user.user_id)

        return render('admin/users/notifications.html'),

from rhodecode.model.notification import NotificationModel

        c.unread_notifications = NotificationModel()\

                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)

    notifications = relationship('Notification', secondary='user_to_notification')

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = ({'extend_existing':True})

    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

    subject = Column('subject', Unicode(512), nullable=True)

    body = Column('body', Unicode(50000), nullable=True)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    user_notifications = relationship('UserNotification',

        primaryjoin = 'Notification.notification_id==UserNotification.notification_id',

        cascade = "all, delete, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()\

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

    @classmethod

    def create(cls, subject, body, recipients):

        notification = cls()

        notification.subject = subject

        notification.body = body

        Session.add(notification)

        for u in recipients:

            u.notifications.append(notification)

        Session.commit()

        return notification

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = ({'extend_existing':True})

    user_to_notification_id = Column("user_to_notification_id", Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), nullable=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', single_parent=True, lazy="joined")

    notification = relationship('Notification',single_parent=True,

                                cascade="all, delete, delete-orphan")

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

"""

    rhodecode.model.notification

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

    Model for notifications

    :created_on: Nov 20, 2011

    :author: marcink

    :copyright: (C) 2009-2011 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 traceback

from pylons.i18n.translation import _

from rhodecode.lib import safe_unicode

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

class NotificationModel(BaseModel):

    def create(self, subject, body, recipients):

        if not getattr(recipients, '__iter__', False):

            raise Exception('recipients must be a list of iterable')

        for x in recipients:

            if not isinstance(x, User):

                raise Exception('recipient is not instance of %s got %s' % \

                                (User, type(x)))

        Notification.create(subject, body, recipients)

    def get_for_user(self, user_id):

        return User.get(user_id).notifications

    def get_unread_cnt_for_user(self, user_id):

        return UserNotification.query()\

                .filter(UserNotification.sent_on == None)\

                .filter(UserNotification.user_id == user_id).count()

    def get_unread_for_user(self, user_id):

        return [x.notification for x in UserNotification.query()\

                .filter(UserNotification.sent_on == None)\

                .filter(UserNotification.user_id == user_id).all()]

	border: 0px solid #D0D0D0;

.notifications{

	width:22px;

    padding:2px;

	float:right;

    -webkit-border-radius: 4px;

    -moz-border-radius: 4px;

    border-radius: 4px;

    text-align: center;

    margin: -1px -10px 0px 5px;

    background-color: #DEDEDE;

}

.notifications a{

	color:#888 !important;

	display: block;

	font-size: 10px

}

.notifications a:hover{

	text-decoration: none !important;

}

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

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

<%def name="title()">

    ${_('My Notifications')} ${c.rhodecode_user.username} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${_('My Notifications')}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}       

    </div>

    % for notification in c.notifications:

        ${notification.title}

    %else:

        <div class="table">${_('No notifications here yet')}</div>

    %endfor

</div>    

</%def>  

            <div class="notifications">

            <a href="${h.url('admin_settings_notifications')}">${c.unread_notifications}</a>

            </div>

from rhodecode.model.db import RepoGroup, User, Notification, UserNotification

from rhodecode.model.user import UserModel

from rhodecode.model import meta

Session = meta.Session()

class TestNotifications(unittest.TestCase):

    def setUp(self):

        self.u1 = UserModel().create_or_update(username='u1', password='qweqwe',

                                               email='u1@rhodecode.org',

                                               name='u1', lastname='u1')

        self.u2 = UserModel().create_or_update(username='u2', password='qweqwe',

                                               email='u2@rhodecode.org',

                                               name='u2', lastname='u3')

        self.u3 = UserModel().create_or_update(username='u3', password='qweqwe',

                                               email='u3@rhodecode.org',

                                               name='u3', lastname='u3')

    def test_create_notification(self):

        usrs = [self.u1, self.u2]

        notification = Notification.create(subject='subj', body='hi there',

                            recipients=usrs)

        notifications = Session.query(Notification).all()

        unotification = UserNotification.query()\

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

        self.assertEqual(len(notifications), 1)

        self.assertEqual(notifications[0].recipients, [self.u1, self.u2])

        self.assertEqual(notification, notifications[0])

        self.assertEqual(len(unotification), len(usrs))

        self.assertEqual([x.user.user_id for x in unotification],

                         [x.user_id for x in usrs])

    def test_user_notifications(self):

        notification1 = Notification.create(subject='subj', body='hi there',

                            recipients=[self.u3])

        notification2 = Notification.create(subject='subj', body='hi there',

                            recipients=[self.u3])

        self.assertEqual(self.u3.notifications, [notification1, notification2])

    def test_delete_notifications(self):

        notification = Notification.create(subject='title', body='hi there3',

                            recipients=[self.u3, self.u1, self.u2])

        notifications = Notification.query().all()

        self.assertTrue(notification in notifications)

        Notification.delete(notification.notification_id)

        notifications = Notification.query().all()

        self.assertFalse(notification in notifications)

        un = UserNotification.query().filter(UserNotification.notification

                                             == notification).all()

        self.assertEqual(un, [])

    def tearDown(self):

        User.delete(self.u1.user_id)

        User.delete(self.u2.user_id)

        User.delete(self.u3.user_id)