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)