try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,

                                                            end=rev_end)

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        cumulative_diff = 0

        c.cut_off = False  # defines if cut off limit is reached

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.comments = []

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            c.statuses.extend([ChangesetStatusModel()\

                              .get_status(c.rhodecode_db_repo.repo_id,

                                          changeset.raw_id)])

            c.comments.extend(ChangesetCommentsModel()\

                              .get_comments(c.rhodecode_db_repo.repo_id,

                                            changeset.raw_id))

            inlines = ChangesetCommentsModel()\

                        .get_inline_comments(c.rhodecode_db_repo.repo_id,

                                             changeset.raw_id)

            c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

            #==================================================================

            # ADDED FILES

            #==================================================================

            for node in changeset.added:

                fid = h.FID(revision, node.path)

                line_context_lcl = get_line_ctx(fid, request.GET)

                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

                lim = self.cut_off_limit

                if cumulative_diff > self.cut_off_limit:

                    lim = -1 if limit_off is None else None

                size, cs1, cs2, diff, st = wrapped_diff(

                    filenode_old=None,

                    filenode_new=node,

                    cut_off_limit=lim,

                    ignore_whitespace=ign_whitespace_lcl,

                    line_context=line_context_lcl,

                    enable_comments=enable_comments

                )

                cumulative_diff += size

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(

                    ('added', node, diff, cs1, cs2, st)

                )

            #==================================================================

            # CHANGED FILES

            #==================================================================

            for node in changeset.changed:

                try:

                    filenode_old = changeset_parent.get_node(node.path)

                except ChangesetError:

                    log.warning('Unable to fetch parent node for diff')

                    filenode_old = FileNode(node.path, '', EmptyChangeset())

                fid = h.FID(revision, node.path)

                line_context_lcl = get_line_ctx(fid, request.GET)

                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

                lim = self.cut_off_limit

                if cumulative_diff > self.cut_off_limit:

                    lim = -1 if limit_off is None else None

                size, cs1, cs2, diff, st = wrapped_diff(

                    filenode_old=filenode_old,

                    filenode_new=node,

                    cut_off_limit=lim,

                    ignore_whitespace=ign_whitespace_lcl,

                    line_context=line_context_lcl,

                    enable_comments=enable_comments

                )

                cumulative_diff += size

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(

                    ('changed', node, diff, cs1, cs2, st)

                )

            #==================================================================

            # REMOVED FILES

            #==================================================================

            for node in changeset.removed:

                c.changes[changeset.raw_id].append(

                    ('removed', node, None, None, None, (0, 0))

                )

        # count inline comments

        for path, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = request.GET.get('context', 3)

        try:

            c.scm_type = c.rhodecode_repo.alias

            c.changeset = c.rhodecode_repo.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                cs2 = node.changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = filenode_old.changeset.raw_id

                cs2 = node.changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' \

                                            % revision

        c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                 for x in c.changeset.parents])

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    @jsonify

    def comment(self, repo_name, revision):

        comm = 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'),

        )

        # get status if set !

            ChangesetStatusModel().set_status(

                c.rhodecode_db_repo.repo_id,

                revision,

                status,

                c.rhodecode_user.user_id,

                comm,

            )

        Session.commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

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

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

            ChangesetCommentsModel().delete(comment=co)

            Session.commit()

            return True

        else:

            raise HTTPForbidden()

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

"""

    rhodecode.model.comment

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

    comments model for RhodeCode

    :created_on: Nov 11, 2011

    :author: marcink

    :copyright: (C) 2011-2012 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 sqlalchemy.util.compat import defaultdict

from rhodecode.lib.utils2 import extract_mentioned_users, safe_unicode

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

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

from rhodecode.model.notification import NotificationModel

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    def __get_changeset_comment(self, changeset_comment):

        return self._get_instance(ChangesetComment, changeset_comment)

    def _extract_mentions(self, s):

        user_objects = []

        for username in extract_mentioned_users(s):

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

            if user_obj:

                user_objects.append(user_obj)

        return user_objects

    def create(self, text, repo_id, user_id, revision, f_path=None,

        """

        :param text:

        :param repo_id:

        :param user_id:

        :param revision:

        :param f_path:

        :param line_no:

        """

        if text:

            repo = Repository.get(repo_id)

            cs = repo.scm_instance.get_changeset(revision)

            desc = "%s - %s" % (cs.short_id, h.shorter(cs.message, 256))

            author_email = cs.author_email

            comment = ChangesetComment()

            comment.repo = repo

            comment.user_id = user_id

            comment.revision = revision

            comment.text = text

            comment.f_path = f_path

            comment.line_no = line_no

            self.sa.add(comment)

            self.sa.flush()

            # make notification

            line = ''

            if line_no:

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

            subj = safe_unicode(

                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,

                                qualified=True,

                          )

                )

            )

            body = text

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's in rhodecode system

            recipients += [User.get_by_email(author_email)]

            NotificationModel().create(

              created_by=user_id, subject=subj, body=body,

            )

            mention_recipients = set(self._extract_mentions(body))\

                                    .difference(recipients)

            if mention_recipients:

                subj = _('[Mention]') + ' ' + subj

                NotificationModel().create(

                    created_by=user_id, subject=subj, body=body,

                    recipients=mention_recipients,

                    type_=Notification.TYPE_CHANGESET_COMMENT

                )

            return comment

    def delete(self, comment):

        """

        Deletes given comment

        :param comment_id:

        """

        comment = self.__get_changeset_comment(comment)

        self.sa.delete(comment)

        return comment

    def get_comments(self, repo_id, revision):

        return ChangesetComment.query()\

                .filter(ChangesetComment.repo_id == repo_id)\

                .filter(ChangesetComment.revision == revision)\

                .filter(ChangesetComment.line_no == None)\

                .filter(ChangesetComment.f_path == None).all()

    def get_inline_comments(self, repo_id, revision):

        comments = self.sa.query(ChangesetComment)\

            .filter(ChangesetComment.repo_id == repo_id)\

            .filter(ChangesetComment.revision == revision)\

            .filter(ChangesetComment.line_no != None)\

            .filter(ChangesetComment.f_path != None)\

            .order_by(ChangesetComment.comment_id.asc())\

            .all()

        paths = defaultdict(lambda: defaultdict(list))

        for co in comments:

            paths[co.f_path][co.line_no].append(co)

        return paths.items()

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id'),

        UniqueConstraint('user_id', 'follows_user_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

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

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

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

    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

    follows_repository = relationship('Repository', order_by='Repository.repo_name')

    @classmethod

    def get_repo_followers(cls, repo_id):

        return cls.query().filter(cls.follows_repo_id == repo_id)

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        UniqueConstraint('cache_key'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

    def __init__(self, cache_key, cache_args=''):

        self.cache_key = cache_key

        self.cache_args = cache_args

        self.cache_active = False

    def __unicode__(self):

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

                                  self.cache_id, self.cache_key)

    @classmethod

    def clear_cache(cls):

        cls.query().delete()

    @classmethod

    def _get_key(cls, key):

        """

        Wrapper for generating a key, together with a prefix

        :param key:

        """

        import rhodecode

        prefix = ''

        iid = rhodecode.CONFIG.get('instance_id')

        if iid:

            prefix = iid

        return "%s%s" % (prefix, key), prefix, key.rstrip('_README')

    @classmethod

    def get_by_key(cls, key):

        return cls.query().filter(cls.cache_key == key).scalar()

    @classmethod

    def _get_or_create_key(cls, key, prefix, org_key):

        inv_obj = Session.query(cls).filter(cls.cache_key == key).scalar()

        if not inv_obj:

            try:

                inv_obj = CacheInvalidation(key, org_key)

                Session.add(inv_obj)

                Session.commit()

            except Exception:

                log.error(traceback.format_exc())

                Session.rollback()

        return inv_obj

    @classmethod

    def invalidate(cls, key):

        """

        Returns Invalidation object if this given key should be invalidated

        None otherwise. `cache_active = False` means that this cache

        state is not valid and needs to be invalidated

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv = cls._get_or_create_key(key, _prefix, _org_key)

        if inv and inv.cache_active is False:

            return inv

    @classmethod

    def set_invalidate(cls, key):

        """

        Mark this Cache key for invalidation

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv_objs = Session.query(cls).filter(cls.cache_args == _org_key).all()

        log.debug('marking %s key[s] %s for invalidation' % (len(inv_objs),

                                                             _org_key))

        try:

            for inv_obj in inv_objs:

                if inv_obj:

                    inv_obj.cache_active = False

                Session.add(inv_obj)

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

            Session.rollback()

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = cls.get_by_key(key)

        inv_obj.cache_active = True

        Session.add(inv_obj)

        Session.commit()

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

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

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column('revision', String(40), nullable=False)

    line_no = Column('line_no', Unicode(10), nullable=True)

    f_path = Column('f_path', Unicode(1000), nullable=True)

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    text = Column('text', Unicode(25000), nullable=False)

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

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    status_change = relationship('ChangesetStatus', uselist=False)

    @classmethod

    def get_users(cls, revision):

        """

        Returns user associated with this changesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        return Session.query(User)\

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

class ChangesetStatus(Base, BaseModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        UniqueConstraint('repo_id', 'revision', 'version'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

    STATUSES = [

        ('not_reviewed', _("Not Reviewed")),  # (no icon) and default

        ('approved', _("Approved")),

        ('rejected', _("Rejected")),

        ('under_review', _("Under Review")),

    ]

    DEFAULT = STATUSES[0][0]

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

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

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

    revision = Column('revision', String(40), nullable=False)

    status = Column('status', String(128), nullable=False, default=DEFAULT)

    changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))

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

    version = Column('version', Integer(), nullable=False, default=0)

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    comment = relationship('ChangesetComment', lazy='joined')

    @property

    def status_lbl(self):

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    TYPE_PULL_REQUEST = u'pull_request'

    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_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

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

    type_ = Column('type', Unicode(256))

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', lazy='joined',

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

    @property

    def recipients(self):

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

                .filter(UserNotification.notification == self)\

                .order_by(UserNotification.user).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for u in recipients:

            assoc = UserNotification()

            assoc.notification = notification

            u.notifications.append(assoc)

        Session.add(notification)

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

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

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

    notification = relationship('Notification', lazy="joined",

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

    def mark_as_read(self):

        self.read = True

        Session.add(self)

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

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

"""

    rhodecode.model.notification

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

    Model for notifications

    :created_on: Nov 20, 2011

    :author: marcink

    :copyright: (C) 2010-2012 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 os

import logging

import traceback

import datetime

from pylons.i18n.translation import _

import rhodecode

from rhodecode.config.conf import DATETIME_FORMAT

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

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

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def __get_user(self, user):

        return self._get_instance(User, user, callback=User.get_by_username)

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, (int, long)):

            return Notification.get(notification)

        else:

            if notification:

                raise Exception('notification must be int, long or Instance'

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

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

               email_kwargs={}):

        """

        Creates notification of given type

        :param created_by: int, str or User instance. User who created this

            notification

        :param subject:

        :param body:

        :param recipients: list of int, str or User objects, when None

            is given send to all admins

        :param type_: type of notification

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        from rhodecode.lib.celerylib import tasks, run_task

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

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

        created_by_obj = self.__get_user(created_by)

        if recipients:

            recipients_objs = []

            for u in recipients:

                obj = self.__get_user(u)

                if obj:

                    recipients_objs.append(obj)

            recipients_objs = set(recipients_objs)

            log.debug('sending notifications %s to %s' % (

                type_, recipients_objs)

            )

        else:

            # empty recipients means to all admins

            recipients_objs = User.query().filter(User.admin == True).all()

            log.debug('sending notifications %s to admins: %s' % (

                type_, recipients_objs)

            )

        notif = Notification.create(

            created_by=created_by_obj, subject=subject,

            body=body, recipients=recipients_objs, type_=type_

        )

        if with_email is False:

            return notif

        # send email with notification

        for rec in recipients_objs:

            email_subject = NotificationModel().make_description(notif, False)

            type_ = type_

            email_body = body

            kwargs = {'subject': subject, 'body': h.rst_w_mentions(body)}

            kwargs.update(email_kwargs)

            email_body_html = EmailNotificationModel()\

                                .get_email_tmpl(type_, **kwargs)

            run_task(tasks.send_email, rec.email, email_subject, email_body,

                     email_body_html)

        return notif

    def delete(self, user, notification):

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

        try:

            notification = self.__get_notification(notification)

            user = self.__get_user(user)

            if notification and user:

                obj = UserNotification.query()\

                        .filter(UserNotification.user == user)\

                        .filter(UserNotification.notification

                                == notification)\

                        .one()

                self.sa.delete(obj)

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

    def get_for_user(self, user):

        user = self.__get_user(user)

        return user.notifications

    def mark_all_read_for_user(self, user):

        user = self.__get_user(user)

        UserNotification.query()\

            .filter(UserNotification.read == False)\

            .update({'read': True})

    def get_unread_cnt_for_user(self, user):

        user = self.__get_user(user)

        return UserNotification.query()\

                .filter(UserNotification.read == False)\

                .filter(UserNotification.user == user).count()

    def get_unread_for_user(self, user):

        user = self.__get_user(user)

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

                .filter(UserNotification.read == False)\

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

    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, show_age=True):

        """

        Creates a human readable description based on properties

        of notification object