rmap.connect('branch_tag_switcher', '/branches-tags/{repo_name:.*}',

                 controller='home', action='branch_tag_switcher')

    #NOTIFICATION REST ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/notifications') as m:

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

                  action="create", conditions=dict(method=["POST"]))

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

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

        m.connect("formatted_notifications", "/notifications.{format}",

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

        m.connect("new_notification", "/notifications/new",

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

        m.connect("formatted_new_notification", "/notifications/new.{format}",

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

        m.connect("/notification/{notification_id}",

                  action="update", conditions=dict(method=["PUT"]))

        m.connect("/notification/{notification_id}",

                  action="delete", conditions=dict(method=["DELETE"]))

        m.connect("edit_notification", "/notification/{notification_id}/edit",

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

        m.connect("formatted_edit_notification",

                  "/notification/{notification_id}.{format}/edit",

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

        m.connect("notification", "/notification/{notification_id}",

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

        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",

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

                conditions=dict(function=check_repo, method=["DELETE"]))

import logging

from pylons import tmpl_context as c

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib import helpers as h

log = logging.getLogger(__name__)

class NotificationsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('notification', 'notifications', controller='_admin/notifications', 

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

    def __before__(self):

        super(NotificationsController, self).__before__()

    def index(self, format='html'):

        """GET /_admin/notifications: All items in the collection"""

        # url('notifications')

        c.user = self.rhodecode_user

        c.notifications = NotificationModel()\

                            .get_for_user(self.rhodecode_user.user_id)

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

    def create(self):

        """POST /_admin/notifications: Create a new item"""

        # url('notifications')

    def new(self, format='html'):

        """GET /_admin/notifications/new: Form to create a new item"""

        # url('new_notification')

    def update(self, notification_id):

        """PUT /_admin/notifications/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('notification', notification_id=ID),

        #           method='put')

        # url('notification', notification_id=ID)

    def delete(self, notification_id):

        """DELETE /_admin/notifications/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('notification', notification_id=ID),

        #           method='delete')

        # url('notification', notification_id=ID)

        no = Notification.get(notification_id)

        owner = lambda: no.notifications_to_users.user.user_id == c.rhodecode_user.user_id

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

                NotificationModel().delete(notification_id)

                return 'ok'

        return 'fail'

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

        """GET /_admin/notifications/id: Show a specific item"""

        # url('notification', notification_id=ID)

        c.user = self.rhodecode_user

        c.notification = Notification.get(notification_id)

        unotification = NotificationModel()\

                            .get_user_notification(c.user.user_id,

                                                   c.notification)

        if unotification.read is False:

            unotification.mark_as_read()

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

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

        """GET /_admin/notifications/id/edit: Form to edit an existing item"""

        # url('edit_notification', notification_id=ID)

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

        ChangesetCommentsModel().create(text=request.POST.get('text'),

                                        repo_id=c.rhodecode_db_repo.repo_id,

                                        user_id=c.rhodecode_user.user_id,

                                        revision=revision,

                                        f_path=request.POST.get('f_path'),

                                        line_no=request.POST.get('line'))

        owner = lambda : co.author.user_id == c.rhodecode_user.user_id

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

import re

from pylons.i18n.translation import _

from sqlalchemy.util.compat import defaultdict

from rhodecode.lib import helpers as h

from rhodecode.model.db import ChangesetComment, User, Repository, Notification

    def _extract_mentions(self, s):

        usrs = []

        for username in re.findall(r'(?:^@|\s@)(\w+)', s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

                usrs.append(user_obj)

        return usrs

            repo = Repository.get(repo_id)

            desc = repo.scm_instance.get_changeset(revision).message

            comment.repo = repo

            self.sa.flush()

            line = ''

            if line_no:

                line = _('on line %s') % line_no

            subj = h.link_to('Re commit: %(commit_desc)s %(line)s' % \

                                    {'commit_desc':desc,'line':line},

                             h.url('changeset_home', repo_name=repo.repo_name,

                                   revision = revision,

                                   anchor = 'comment-%s' % comment.comment_id

                                   )

                             )

            recipients += self._extract_mentions(body)

    notifications = relationship('Notification',

                            secondary='user_to_notification',

                            order_by=lambda :Notification.created_on.desc())

        return "<%s('id:%s:%s')>" % (self.__class__.__name__,

                                     self.user_id, self.username)

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification',

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

        lazy='joined',

        notification.created_by_user = created_by

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

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

    def mark_as_read(self):

        self.read = True

        Session.add(self)

        Session.commit()

                    query_cls = caching_query.query_callable(cache_manager),

                    expire_on_commit = True,

from rhodecode.lib.helpers import age

log = logging.getLogger(__name__)

    def __get_user(self, user):

        if isinstance(user, User):

            return user

        elif isinstance(user, basestring):

            return User.get_by_username(username=user)

        elif isinstance(user, int):

            return User.get(user)

        else:

            raise Exception('Unsupported user must be one of int,'

                            'str or User object')

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, int):

            return Notification.get(notification)

        else:

            if notification:

                raise Exception('notification must be int or Instance'

                                ' of Notification got %s' % type(notification))

        created_by_obj = self.__get_user(created_by)

            recipients_objs.append(self.__get_user(u))

        recipients_objs = set(recipients_objs)

        return Notification.create(created_by=created_by_obj, subject=subject,

                            body=body, recipients=recipients_objs,

    def delete(self, notification_id):

        # we don't want to remove actuall notification just the assignment

        try:

            notification_id = int(notification_id)

            no = self.__get_notification(notification_id)

            if no:

                UserNotification.delete(no.notifications_to_users.user_to_notification_id)

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

                .filter(UserNotification.read == False)\

                .filter(UserNotification.read == False)\

    def get_user_notification(self, user, notification):

        user = self.__get_user(user)

        notification = self.__get_notification(notification)

        return UserNotification.query()\

            .filter(UserNotification.notification == notification)\

            .filter(UserNotification.user == user).scalar()

    def make_description(self, notification):

        """

        Creates a human readable description based on properties

        of notification object

        """

        _map = {notification.TYPE_CHANGESET_COMMENT:_('commented on commit'),

                notification.TYPE_MESSAGE:_('sent message'),

                notification.TYPE_MENTION:_('mentioned you')}

        tmpl = "%(user)s %(action)s %(when)s"

        data = dict(user=notification.created_by_user.username,

                    action=_map[notification.type_],

                    when=age(notification.created_on))

        return tmpl % data

	padding: 2px 2px 2px 2px;

    line-height:0;

}

.notification-header{

}

.notification-header .desc{

	font-size: 16px;

    height: 24px;

    padding-top: 6px;

    float: left

}

.notification-header .desc.unread{

    font-weight: bold;

    font-size: 17px;

}

.notification-header .delete-notifications{

    float: right;

    padding-top: 8px;

    cursor: pointer;

}

.notification-subject{

    clear:both;

    border-bottom: 1px solid #eee;

    padding:5px 0px 5px 38px;

var deleteNotification = function(url, notification_id){

    var callback = { 

		success:function(o){

		    var obj = YUD.get(String("notification_"+notification_id));

			obj.parentNode.removeChild(obj);

		},

	    failure:function(o){

	        alert("error");

	    },

	};

    var postData = '_method=delete';

    var sUrl = url.replace('__NOTIFICATION_ID__',notification_id);

    var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, 

    											  callback, postData);

};	

    <%

    unread = lambda n:{False:'unread'}.get(n)

    %>

    <div class="table">

        <div id="notification_${notification.notification_id}">

          <div class="notification-header">

            <div class="gravatar">

                <img alt="gravatar" src="${h.gravatar_url(h.email(notification.created_by_user.email),24)}"/>

            </div>

            <div class="desc">

            <a href="${url('notification', notification_id=notification.notification_id)}">${notification.description}</a>

            </div>

            <div class="delete-notifications">

              <span id="${notification.notification_id}" class="delete-notification delete_icon action"></span>

            </div>

          <div class="notification-subject">${h.urlify_text(notification.subject)}</div>

        </div>

    </div>

</div>

<script type="text/javascript">

var url = "${url('notification', notification_id='__NOTIFICATION_ID__')}";

   YUE.on(YUQ('.delete-notification'),'click',function(e){

	   var notification_id = e.currentTarget.id;

	   deleteNotification(url,notification_id)

   })

</script>

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

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

<%def name="title()">

    ${_('Show notification')} ${c.rhodecode_user.username} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Notifications'),h.url('notifications'))}

    » 

    ${_('Show notification')}

</%def>

<%def name="page_nav()">

    ${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}       

        <ul class="links">

            <li>

              <span style="text-transform: uppercase;"><a href="#">${_('Compose message')}</a></span>

            </li>          

        </ul>            

    </div>

    <div class="table">

      <div class="notification-header">

        <div class="gravatar">

            <img alt="gravatar" src="${h.gravatar_url(h.email(c.notification.created_by_user.email),24)}"/>

        </div>

        <div class="desc">

            ${c.notification.description}

        </div>

        <div class="delete-notifications">

          <span id="${c.notification.notification_id}" class="delete_icon action"></span>

        </div>

      </div>

      <div>${h.rst(c.notification.body)}</div>

    </div>

</div>

<script type="text/javascript">

var url = "${url('notification', notification_id='__NOTIFICATION_ID__')}";

   YUE.on(YUQ('.delete-notification'),'click',function(e){

       var notification_id = e.currentTarget.id;

       deleteNotification(url,notification_id)

   })

</script>

</%def>  

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

import logging

from rhodecode.model.db import User

        self._logged_username = username

    def _get_logged_user(self):

        return User.get_by_username(self._logged_username)

from rhodecode.tests import *

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

from rhodecode.model.user import UserModel

from rhodecode.model.notification import NotificationModel

class TestNotificationsController(TestController):

    def test_index(self):

        self.log_user()

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

                                               email='u1@rhodecode.org',

                                               name='u1', lastname='u1').user_id

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

                                               email='u2@rhodecode.org',

                                               name='u2', lastname='u2').user_id

        response = self.app.get(url('notifications'))

        self.assertTrue('''<div class="table">No notifications here yet</div>'''

                        in response.body)

        cur_user = self._get_logged_user()

        NotificationModel().create(created_by=u1, subject=u'test',

                                   body=u'notification_1',

                                   recipients=[cur_user])

        response = self.app.get(url('notifications'))

        self.assertTrue(u'notification_1' in response.body)

        User.delete(u1)

        User.delete(u2)

#    def test_index_as_xml(self):

#        response = self.app.get(url('formatted_notifications', format='xml'))

#

#    def test_create(self):

#        response = self.app.post(url('notifications'))

#

#    def test_new(self):

#        response = self.app.get(url('new_notification'))

#

#    def test_new_as_xml(self):

#        response = self.app.get(url('formatted_new_notification', format='xml'))

#

#    def test_update(self):

#        response = self.app.put(url('notification', notification_id=1))

#

#    def test_update_browser_fakeout(self):

#        response = self.app.post(url('notification', notification_id=1), params=dict(_method='put'))

    def test_delete(self):

        self.log_user()

        cur_user = self._get_logged_user()

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

                                               email='u1@rhodecode.org',

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

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

                                               email='u2@rhodecode.org',

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

        # make two notifications 

        notification = NotificationModel().create(created_by=cur_user,

                                                  subject=u'test',

                                                  body=u'hi there',

                                                  recipients=[cur_user, u1, u2])

        u1 = User.get(u1.user_id)

        u2 = User.get(u2.user_id)

        # check DB

        self.assertEqual(u1.notifications, [notification])

        self.assertEqual(u2.notifications, [notification])

        cur_usr_id = cur_user.user_id

        response = self.app.delete(url('notification',

                                       notification_id=cur_usr_id))

        cur_user = self._get_logged_user()

        self.assertEqual(cur_user.notifications, [])

        User.delete(u1.user_id)

        User.delete(u2.user_id)

#    def test_delete_browser_fakeout(self):

#        response = self.app.post(url('notification', notification_id=1), params=dict(_method='delete'))

    def test_show(self):