Advanced deprecation of user-based messages and the LegacyFallbackStorage in contrib.messages.

############

# Class to use as messges backend

MESSAGE_STORAGE = 'django.contrib.messages.storage.user_messages.LegacyFallbackStorage'

MESSAGE_STORAGE = 'django.contrib.messages.storage.fallback.FallbackStorage'

# Default values of MESSAGE_LEVEL and MESSAGE_TAGS are defined within

# django.contrib.messages to avoid imports in this settings file.

        return _user_has_module_perms(self, app_label)

    def get_and_delete_messages(self):

        messages = []

        for m in self.message_set.all():

            messages.append(m.message)

            m.delete()

        return messages

    def email_user(self, subject, message, from_email=None):

        "Sends an email to this User."

        from django.core.mail import send_mail

        return self._profile_cache

class Message(models.Model):

    """

    The message system is a lightweight way to queue messages for given

    users. A message is associated with a User instance (so it is only

    applicable for registered users). There's no concept of expiration or

    timestamps. Messages are created by the Django admin after successful

    actions. For example, "The poll Foo was created successfully." is a

    message.

    """

    user = models.ForeignKey(User, related_name='_message_set')

    message = models.TextField(_('message'))

    def __unicode__(self):

        return self.message

class AnonymousUser(object):

    id = None

    username = ''

    """

    if hasattr(request, '_messages'):

        return request._messages.add(level, message, extra_tags)

    if hasattr(request, 'user') and request.user.is_authenticated():

        return request.user.message_set.create(message=message)

    if not fail_silently:

        raise MessageFailure('Without the django.contrib.messages '

                                'middleware, messages can only be added to '

"""

Storages used to assist in the deprecation of contrib.auth User messages.

"""

from django.contrib.messages import constants

from django.contrib.messages.storage.base import BaseStorage, Message

from django.contrib.auth.models import User

from django.contrib.messages.storage.fallback import FallbackStorage

class UserMessagesStorage(BaseStorage):

    """

    Retrieves messages from the User, using the legacy user.message_set API.

    This storage is "read-only" insofar as it can only retrieve and delete

    messages, not store them.

    """

    session_key = '_messages'

    def _get_messages_queryset(self):

        """

        Returns the QuerySet containing all user messages (or ``None`` if

        request.user is not a contrib.auth User).

        """

        user = getattr(self.request, 'user', None)

        if isinstance(user, User):

            return user._message_set.all()

    def add(self, *args, **kwargs):

        raise NotImplementedError('This message storage is read-only.')

    def _get(self, *args, **kwargs):

        """

        Retrieves a list of messages assigned to the User.  This backend never

        stores anything, so all_retrieved is assumed to be False.

        """

        queryset = self._get_messages_queryset()

        if queryset is None:

            # This is a read-only and optional storage, so to ensure other

            # storages will also be read if used with FallbackStorage an empty

            # list is returned rather than None.

            return [], False

        messages = []

        for user_message in queryset:

            messages.append(Message(constants.INFO, user_message.message))

        return messages, False

    def _store(self, messages, *args, **kwargs):

        """

        Removes any messages assigned to the User and returns the list of

        messages (since no messages are stored in this read-only storage).

        """

        queryset = self._get_messages_queryset()

        if queryset is not None:

            queryset.delete()

        return messages

class LegacyFallbackStorage(FallbackStorage):

    """

    Works like ``FallbackStorage`` but also handles retrieving (and clearing)

    contrib.auth User messages.

    """

    storage_classes = (UserMessagesStorage,) + FallbackStorage.storage_classes

from django.contrib.messages.tests.fallback import FallbackTest

from django.contrib.messages.tests.middleware import MiddlewareTest

from django.contrib.messages.tests.session import SessionTest

from django.contrib.messages.tests.user_messages import \

                                           UserMessagesTest, LegacyFallbackTest