def add(self, level, message, extra_tags='', subject='', user=None, from_user=None, expires=None, close_timeout=None):
"""
Queues a message to be stored.
The message is only queued if it contained something and its level is
not less than the recording level (``self.level``).
"""
to_user = user or get_user(self.request)
if not to_user.is_authenticated():
if Message(level=level).is_persistent():
raise NotImplementedError('Persistent message levels cannot be used for anonymous users.')
else:
return super(PersistentMessageStorage, self).add(level, message, extra_tags)
if not message:
return
# Check that the message level is not less than the recording level.
level = int(level)
if level < self.level:
return
# Add the message.
message = Message(user=to_user, level=level, message=message, extra_tags=extra_tags, subject=subject, from_user=from_user, expires=expires, close_timeout=close_timeout)
# Messages need a primary key when being displayed so that they can be closed/marked as read by the user.
# Hence, save it now instead of adding it to queue:
if STORE_WHEN_ADDING:
message.save()
else:
self.added_new = True
self._queued_messages.append(message)
def deliver(self, recipient, sender, notice_type, extra_context):
context = self.default_context()
context.update(extra_context)
if shadow_ban_applies(notice_type, recipient, context):
return
template = 'notice.html'
message = self.get_formatted_messages([template], notice_type.label,
context)[template]
level = persistent_messages.INFO
try:
request = get_request()
persistent_messages.add_message(request,
level,
message,
user=recipient,
from_user=sender)
except IndexError:
persistent_message = Message(user=recipient,
from_user=sender,
level=level,
message=message)
persistent_message.save()
def add_async_message(level, message, extra_tags='',
fail_silently=False, subject='', user=None, email=False,
from_user=None, expires=None, close_timeout=None):
from persistent_messages.models import Message
if not user:
raise Exception("User must be supplied to async message")
if email:
notify.email(level, message, extra_tags, subject, user, from_user)
message = Message(user=user, level=level, message=message,
extra_tags=extra_tags, subject=subject,
from_user=from_user, expires=expires,
close_timeout=close_timeout)
message.save()
return message
def save(self, from_user, parent_msg=None):
subject = self.cleaned_data['subject']
message = self.cleaned_data['message']
to_user = get_object_or_404(User, username=self.cleaned_data['to_user'])
level = constants.MESSAGE
# Update the parent_msg `replied` field to true
if parent_msg is not None:
parent_msg.replied = True
parent_msg.save()
message = Message(user=to_user, level=level, message=message, subject=subject, from_user=from_user, parent_msg=parent_msg)
return message.save()
def add(self,
level,
message,
extra_tags='',
subject='',
user=None,
from_user=None,
expires=None,
close_timeout=None):
"""
Queues a message to be stored.
The message is only queued if it contained something and its level is
not less than the recording level (``self.level``).
"""
to_user = user or get_user(self.request)
if not to_user.is_authenticated():
if Message(level=level).is_persistent():
raise NotImplementedError(
'Persistent message levels cannot be used for anonymous users.'
)
else:
return super(PersistentMessageStorage,
self).add(level, message, extra_tags)
if not message:
return
# Check that the message level is not less than the recording level.
level = int(level)
if level < self.level:
return
# Add the message.
message = Message(user=to_user,
level=level,
message=message,
extra_tags=extra_tags,
subject=subject,
from_user=from_user,
expires=expires,
close_timeout=close_timeout)
# Messages need a primary key when being displayed so that they can be closed/marked as read by the user.
# Hence, save it now instead of adding it to queue:
if STORE_WHEN_ADDING:
message.save()
else:
self.added_new = True
self._queued_messages.append(message)
def add(self, level, message, extra_tags='', subject='', user=None, from_user=None, expires=None, close_timeout=None):
"""
Adds or queues a message to the storage
:param level: Level of the message
:param message: Message text to be saved
:param extra_tags: String with separated tags to add to message Ex: "secret classified"
:param subject: Subject of the message
:param user: `auth.User` that receives the message
:param from_user: `auth.User` that sends the message
:param expires: Timestamp that indicates when the message expires
:param close_timeout: Integer
.. note:: The message is only saved if it contains something and its level is over the recorded level (`MESSAGE_LEVEL`) `self.level`
"""
to_user = user or get_user(self.request)
if not to_user.is_authenticated():
if Message(level=level).is_persistent():
raise NotImplementedError('Persistent message levels cannot be used for anonymous users.')
else:
return super(PersistentMessageStorage, self).add(level, message, extra_tags)
if not message:
return
# Save the message only if its level is over the recorded level, see `MESSAGE_LEVEL` in Django docs
level = int(level)
if level < self.level:
return
# Add the message
message = Message(user=to_user, level=level, message=message, extra_tags=extra_tags, subject=subject,
from_user=from_user, expires=expires, close_timeout=close_timeout)
# Messages need a primary key when being displayed so that they can be closed/marked as read by the user.
# Hence, save it now instead of adding it to queue:
if STORE_WHEN_ADDING:
message.save()
return message
else:
self.added_new = True
self._queued_messages.append(message)
