def create_offline_message(user,
message,
level=constants.INFO,
read=False,
content_object=None,
meta={}):
if not isinstance(user, User):
user = User.objects.get(username=user)
level_tags = get_level_tags()
label_tag = force_unicode(level_tags.get(level, ''), strings_only=True)
kwargs = dict(
user=user,
level=level,
tags=label_tag,
read=read,
message=message,
meta=dict(meta)
)
if content_object:
kwargs['content_object'] = content_object
return OfflineMessage.objects.create(**kwargs)
def create_offline_message(user,
message,
level=constants.INFO,
read=False,
content_object=None,
meta={}):
if not isinstance(user, get_user_model()):
user = get_user_model().objects.get(username=user)
level_tags = get_level_tags()
label_tag = force_unicode(level_tags.get(level, ''), strings_only=True)
kwargs = dict(
user=user,
level=level,
tags=label_tag,
read=read,
message=message,
meta=dict(meta)
)
if content_object:
kwargs['content_object'] = content_object
return OfflineMessage.objects.create(**kwargs)
def enable(self):
super(override_settings_tags, self).enable()
# LEVEL_TAGS is a constant defined in the
# django.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, we need to update that constant too.
self.old_level_tags = base.LEVEL_TAGS
base.LEVEL_TAGS = utils.get_level_tags()
def enable(self):
super(override_settings_tags, self).enable()
# LEVEL_TAGS is a constant defined in the
# django.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, we need to update that constant too.
self.old_level_tags = base.LEVEL_TAGS
base.LEVEL_TAGS = utils.get_level_tags()
def styleguide(request):
now = timezone.now() + timedelta(-1)
domain = mock.Mock(domain="example.com")
# create a bunch of mocked inboxes
inboxes = [
mock.Mock(
inbox="qwerty",
domain=domain,
get_bools_for_labels={"new": False},
last_activity=now,
form=InboxEditForm(request),
),
mock.Mock(
inbox="qwerty",
domain=domain,
get_bools_for_labels={"disabled": True},
last_activity=now,
form=False,
),
mock.Mock(
inbox="qwerty",
domain=domain,
get_bools_for_labels={"new": True, "pinned": True},
last_activity=now,
form=False,
),
]
# emails
emails = [
mock.Mock(
inbox=inboxes[0],
get_bools_for_labels={"important": True},
received_date=now,
),
mock.Mock(
inbox=inboxes[0],
get_bools_for_labels={"important": False},
received_date=now,
),
]
# attachments
attachments = [
mock.Mock(id=0, filename=("a" * 100), content_type="blah/blah", get_children=[]),
mock.Mock(id=0, filename="a", content_type=None, get_children=[]),
]
context = {
"inboxes": inboxes,
"emails": emails,
"attachments": attachments,
"form": Form(),
"message_types": [(k, get_level_tags()[v]) for k, v in DEFAULT_LEVELS.items() if k != 'DEBUG'],
}
return TemplateResponse(request, 'inboxen/styleguide.html', context)
def create_offline_message(user, message, level=constants.INFO):
if not isinstance(user, User):
user = User.objects.get(username=user)
level_tags = get_level_tags()
label_tag = force_unicode(level_tags.get(level, ''), strings_only=True)
OfflineMessage.objects.create(user=user,
level=level,
tags=label_tag,
message=message)
def test_custom_tags(self):
settings.MESSAGE_TAGS = {
constants.INFO: "info",
constants.DEBUG: "",
constants.WARNING: "",
constants.ERROR: "bad",
29: "custom",
}
# LEVEL_TAGS is a constant defined in the
# django.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, we need to update that constant too.
base.LEVEL_TAGS = utils.get_level_tags()
try:
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(tags, ["info", "custom", "extra-tag", "", "bad", "success"])
finally:
# Ensure the level tags constant is put back like we found it.
self.restore_setting("MESSAGE_TAGS")
base.LEVEL_TAGS = utils.get_level_tags()
def test_custom_tags(self):
settings.MESSAGE_TAGS = {
constants.INFO: 'info',
constants.DEBUG: '',
constants.WARNING: '',
constants.ERROR: 'bad',
29: 'custom',
}
# LEVEL_TAGS is a constant defined in the
# django.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, we need to update that constant too.
base.LEVEL_TAGS = utils.get_level_tags()
try:
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(
tags, ['info', 'custom', 'extra-tag', '', 'bad', 'success'])
finally:
# Ensure the level tags constant is put back like we found it.
self.restore_setting('MESSAGE_TAGS')
base.LEVEL_TAGS = utils.get_level_tags()
def test_custom_tags(self):
settings.MESSAGE_TAGS = {
constants.INFO: 'info',
constants.DEBUG: '',
constants.WARNING: '',
constants.ERROR: 'bad',
29: 'custom',
}
# LEVEL_TAGS is a constant defined in the
# django_lettuce.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, we need to update that constant too.
base.LEVEL_TAGS = utils.get_level_tags()
try:
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(tags,
['info', 'custom', 'extra-tag', '', 'bad', 'success'])
finally:
# Ensure the level tags constant is put back like we found it.
self.restore_setting('MESSAGE_TAGS')
base.LEVEL_TAGS = utils.get_level_tags()
def create_offline_message(user, message, level=constants.INFO):
if not isinstance(user, get_user_model()):
user = get_user_model().objects.get(username=user)
level_tags = get_level_tags()
label_tag = force_unicode(level_tags.get(level, ''), strings_only=True)
kwargs = dict(
user=user,
level=level,
tags=label_tag,
message=message,
)
return OfflineMessage.objects.create(**kwargs)
from django.contrib.auth import get_user_model
from django.db import models
from django.utils.encoding import force_unicode
from django.contrib import messages
from django.contrib.messages import utils
from django.utils.translation import ugettext_lazy as _
import monitio
from monitio import constants
LEVEL_TAGS = utils.get_level_tags()
User = get_user_model()
class Monit(models.Model):
user = models.ForeignKey(User, blank=True, null=True)
from_user = models.ForeignKey(User, blank=True, null=True,
related_name="from_user")
subject = models.CharField(max_length=255, blank=True, default='')
message = models.TextField()
LEVEL_CHOICES = (
(messages.DEBUG, 'DEBUG'),
(messages.INFO, 'INFO'),
(messages.SUCCESS, 'SUCCESS'),
(messages.WARNING, 'WARNING'),
(messages.ERROR, 'ERROR'),
(constants.DEBUG, 'PERSISTENT DEBUG'),
(constants.INFO, 'PERSISTENT INFO'),
(constants.SUCCESS, 'PERSISTENT SUCCESS'),
(constants.WARNING, 'PERSISTENT WARNING'),
(constants.ERROR, 'PERSISTENT ERROR'),
from __future__ import unicode_literals
import re
from social.backends.oauth import OAuthAuth
from social.backends.utils import load_backends
from urlobject import URLObject
from django.conf import settings
from django.utils.six import text_type
from django.contrib.messages.utils import get_level_tags
from django.utils.encoding import force_text
from django import template
name_re = re.compile(r'([^O])Auth')
LEVEL_TAGS = get_level_tags()
register = template.Library()
@register.simple_tag()
def get_message_tags(message):
"""
Returns the message's level_tag prefixed with Bootstrap's "alert-" prefix
along with any tags included in message.extra_tags
Messages in Django >= 1.7 have a message.level_tag attr
"""
level_tag = force_text(LEVEL_TAGS.get(message.level, ''), strings_only=True)
if level_tag == "error":
# Alias the error tag as danger, since .alert-error no longer exists
def __init__(self,*args,**kwargs): super(AnnouncementAdminForm,self).__init__(*args,**kwargs) level_tags = get_level_tags().values() choices = [(x,x) for x in level_tags] self.fields['message_level'] = forms.ChoiceField(choices=choices)
def tags(self):
level_tags = get_level_tags()
return force_unicode(level_tags.get(self.level, ''), strings_only=True)
def tags(self):
level_tags = get_level_tags()
return force_unicode(level_tags.get(self.level, ''), strings_only=True)
# -*- coding: utf-8 -*-
"""models.py: messages extends"""
from __future__ import unicode_literals
import messages_extends
from django.db import models
from django.utils.encoding import force_text
from django.contrib.messages import utils
from django.conf import settings
LEVEL_TAGS = utils.get_level_tags()
class Message(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, blank=True, null=True)
message = models.TextField()
LEVEL_CHOICES = (
(messages_extends.DEBUG_PERSISTENT, 'PERSISTENT DEBUG'),
(messages_extends.INFO_PERSISTENT, 'PERSISTENT INFO'),
(messages_extends.SUCCESS_PERSISTENT, 'PERSISTENT SUCCESS'),
(messages_extends.WARNING_PERSISTENT, 'PERSISTENT WARNING'),
(messages_extends.ERROR_PERSISTENT, 'PERSISTENT ERROR'),
)
level = models.IntegerField(choices=LEVEL_CHOICES)
extra_tags = models.CharField(max_length=128)
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
read = models.BooleanField(default=False)
expires = models.DateTimeField(null=True, blank=True)
def update_level_tags(setting, **kwargs):
if setting == 'MESSAGE_TAGS':
base.LEVEL_TAGS = get_level_tags()
import json
from collections import namedtuple
import hashlib
from ..exceptions import MessageTypeNotSupported, MessageDoesNotExist
from ..base import StoredMessagesBackend
from .. import signals
from ...settings import stored_messages_settings
try:
# Let django project bootstrap anyway when not using this backend
import redis
except ImportError:
pass
LEVEL_TAGS = get_level_tags()
#Message = namedtuple('Message', ['id', 'message', 'level', 'tags', 'date', 'url'])
Message = namedtuple(
'Message', ['id', 'message', 'level', 'level_tag', 'tags', 'date', 'url'])
class RedisBackend(StoredMessagesBackend):
"""
"""
def __init__(self):
self.client = redis.StrictRedis.from_url(
stored_messages_settings.REDIS_URL)
def _flush(self):
from __future__ import unicode_literals
from django.conf import settings
from django.contrib.messages import constants, utils
from django.utils.encoding import force_text, python_2_unicode_compatible
LEVEL_TAGS = utils.get_level_tags()
@python_2_unicode_compatible
class Message(object):
"""
Represents an actual message that can be stored in any of the supported
storage classes (typically session- or cookie-based) and rendered in a view
or template.
"""
def __init__(self, level, message, extra_tags=None):
self.level = int(level)
self.message = message
self.extra_tags = extra_tags
def _prepare(self):
"""
Prepares the message for serialization by forcing the ``message``
and ``extra_tags`` to unicode in case they are lazy translations.
Known "safe" types (None, int, etc.) are not converted (see Django's
``force_text`` implementation for details).
"""
self.message = force_text(self.message, strings_only=True)
self.extra_tags = force_text(self.extra_tags, strings_only=True)
def __eq__(self, other):
return isinstance(other, Message) and self.level == other.level and \
self.message == other.message
def __str__(self):
