Пример #1
0
 def _get(self, *args, **kwargs):
     # The database backend for persistent messages doesn't support setting
     # messages with ``mark_safe``, therefore, we need to do it broadly here.
     messages, all_ret = (super(FallbackUniqueStorage, self)
                          ._get(self, *args, **kwargs))
     safe_messages = []
     for message in messages:
         # Handle all message types, if the message is persistent, take
         # special action. As the default message handler, this will also
         # process ephemeral messages
         if message.level in PERSISTENT_MESSAGE_LEVELS:
             message_pk = message.pk
             message = Message(message.level,
                               mark_safe(message.message),
                               message.extra_tags)
             message.pk = message_pk
         safe_messages.append(message)
     return safe_messages, all_ret
Пример #2
0
 def process_messages(self, obj):
     if isinstance(obj, list) and obj:
         if obj[0] == MessageEncoder.message_key:
             if obj[1]:
                 obj[3] = mark_safe(obj[3])
             return Message(*obj[2:])
         return [self.process_messages(item) for item in obj]
     if isinstance(obj, dict):
         return {
             key: self.process_messages(value)
             for key, value in obj.items()
         }
     return obj
Пример #3
0
 def test_json_encoder_decoder(self):
     """
     A complex nested data structure containing Message
     instances is properly encoded/decoded by the custom JSON
     encoder/decoder classes.
     """
     messages = [
         {
             'message':
             Message(constants.INFO, 'Test message'),
             'message_list':
             [Message(constants.INFO, 'message %s') for x in range(5)] +
             [{
                 'another-message': Message(constants.ERROR, 'error')
             }],
         },
         Message(constants.INFO, 'message %s'),
     ]
     encoder = MessageEncoder(separators=(',', ':'))
     value = encoder.encode(messages)
     decoded_messages = json.loads(value, cls=MessageDecoder)
     self.assertEqual(messages, decoded_messages)
Пример #4
0
    def test_messages(self):

        for tag in self.tags:
            txt = 'some message with {}'.format(repr(tag))

            test_messages = [Message(tag, txt)]
            self.assertEqual(
                messages(test_messages),
                {'messages': [{
                    'text': txt,
                    'tags': LEVEL_TAGS[tag]
                }]})  # clean one

            txt = '[\'some dirty message with {}\']'.format(repr(tag))
            txt_altered = txt.replace('[\'', '').replace('\']', '')
            test_messages = [Message(tag, txt)]
            self.assertEqual(
                messages(test_messages),
                {'messages': [{
                    'text': txt_altered,
                    'tags': LEVEL_TAGS[tag]
                }]})  # dirty one
 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
Пример #6
0
    def add_unique_message(self, level, message, **kwargs):
        """ Add a message, but only after first making sure it's not already been emitted.

        This helps guard against any message generator adding the same message
        multiple times before the next time the messages are displayed. Once messages
        are displayed, `used` is set on the storage object returned by
        `get_messages()` and the queue is cleared.

        Returns True if message was sent for the first time.
        """
        expected = Message(message=message, level=level, **kwargs)
        if any(msg == expected for msg in messages.get_messages(self.request)):
            return False

        messages.add_message(self.request, level, message, **kwargs)
        return True
Пример #7
0
 def test_legacy_encode_decode(self):
     # RemovedInDjango41Warning: pre-Django 3.2 encoded messages will be
     # invalid.
     storage = self.storage_class(self.get_request())
     messages = [
         'this',
         Message(0, 'Successfully signed in as [email protected]')
     ]
     # Encode/decode a message using the pre-Django 3.2 format.
     encoder = MessageEncoder()
     value = encoder.encode(messages)
     with self.assertRaises(binascii.Error):
         b64_decode(value.encode())
     signer = get_cookie_signer(salt=storage.key_salt)
     encoded_messages = signer.sign(value)
     decoded_messages = storage._decode(encoded_messages)
     self.assertEqual(messages, decoded_messages)
Пример #8
0
 def test_full_request_response_cycle(self):
     """
     With the message middleware enabled, messages are properly stored and
     retrieved across the full request/redirect/response cycle.
     """
     data = {
         'messages': ['Test message %d' % x for x in range(5)],
     }
     show_url = reverse('show_message')
     for level in ('debug', 'info', 'success', 'warning', 'error'):
         add_url = reverse('add_message', args=(level,))
         response = self.client.post(add_url, data, follow=True)
         self.assertRedirects(response, show_url)
         self.assertIn('messages', response.context)
         messages = [Message(self.levels[level], msg) for msg in data['messages']]
         self.assertEqual(list(response.context['messages']), messages)
         for msg in data['messages']:
             self.assertContains(response, msg)
Пример #9
0
 def test_multiple_posts(self):
     """
     Messages persist properly when multiple POSTs are made before a GET.
     """
     data = {
         'messages': ['Test message %d' % x for x in range(5)],
     }
     show_url = reverse('show_message')
     messages = []
     for level in ('debug', 'info', 'success', 'warning', 'error'):
         messages.extend(Message(self.levels[level], msg) for msg in data['messages'])
         add_url = reverse('add_message', args=(level,))
         self.client.post(add_url, data)
     response = self.client.get(show_url)
     self.assertIn('messages', response.context)
     self.assertEqual(list(response.context['messages']), messages)
     for msg in data['messages']:
         self.assertContains(response, msg)
Пример #10
0
 def test_multiple_posts(self):
     """
     Messages persist properly when multiple POSTs are made before a GET.
     """
     data = {
         "messages": ["Test message %d" % x for x in range(5)],
     }
     show_url = reverse("show_message")
     messages = []
     for level in ("debug", "info", "success", "warning", "error"):
         messages.extend(
             Message(self.levels[level], msg) for msg in data["messages"])
         add_url = reverse("add_message", args=(level, ))
         self.client.post(add_url, data)
     response = self.client.get(show_url)
     self.assertIn("messages", response.context)
     self.assertEqual(list(response.context["messages"]), messages)
     for msg in data["messages"]:
         self.assertContains(response, msg)
Пример #11
0
    def add(self, level, message, extra_tags='', *args, **kwargs):
        """
        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``).
        """
        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.
        self.added_new = True
        message = Message(level, message, extra_tags=extra_tags)
        message = self.process_message(message, *args, **kwargs)
        if message:
            self._queued_messages.append(message)
Пример #12
0
def save_form(request):
    """Save the current form in data base. Converts it to XML format first.

    Args:
        request:

    Returns:

    """
    try:
        # get curate data structure
        curate_data_structure_id = request.POST['id']
        curate_data_structure = curate_data_structure_api.get_by_id(
            curate_data_structure_id)

        # unlock from database
        if curate_data_structure.data is not None:
            lock_api.remove_lock_on_object(curate_data_structure.data,
                                           request.user)

        # generate xml data
        xml_data = render_xml(
            curate_data_structure.data_structure_element_root)

        # update curate data structure data
        curate_data_structure.form_string = xml_data

        # save data structure
        curate_data_structure_api.upsert(curate_data_structure)

        # add success message
        message = Message(
            messages.SUCCESS,
            get_form_label().capitalize() + ' saved with success.')

        return HttpResponse(json.dumps({
            'message': message.message,
            'tags': message.tags
        }),
                            content_type='application/json')
    except:
        return HttpResponseBadRequest()
    def test_pre_1_5_message_format(self):
        """
        Messages that were set in the cookie before the addition of is_safedata
        are decoded correctly (#22426).
        """
        # Encode the messages using the current encoder.
        messages = [Message(constants.INFO, 'message %s') for x in range(5)]
        encoder = MessageEncoder(separators=(',', ':'))
        encoded_messages = encoder.encode(messages)

        # Remove the is_safedata flag from the messages in order to imitate
        # the behavior of before 1.5 (monkey patching).
        encoded_messages = json.loads(encoded_messages)
        for obj in encoded_messages:
            obj.pop(1)
        encoded_messages = json.dumps(encoded_messages, separators=(',', ':'))

        # Decode the messages in the old format (without is_safedata)
        decoded_messages = json.loads(encoded_messages, cls=MessageDecoder)
        self.assertEqual(messages, decoded_messages)
Пример #14
0
 def test_full_request_response_cycle(self):
     """
     With the message middleware enabled, messages are properly stored and
     retrieved across the full request/redirect/response cycle.
     """
     data = {
         "messages": ["Test message %d" % x for x in range(5)],
     }
     show_url = reverse("show_message")
     for level in ("debug", "info", "success", "warning", "error"):
         add_url = reverse("add_message", args=(level, ))
         response = self.client.post(add_url, data, follow=True)
         self.assertRedirects(response, show_url)
         self.assertIn("messages", response.context)
         messages = [
             Message(self.levels[level], msg) for msg in data["messages"]
         ]
         self.assertEqual(list(response.context["messages"]), messages)
         for msg in data["messages"]:
             self.assertContains(response, msg)
Пример #15
0
def core_clear_cache(request):
    # Delete caches objects from the database
    data_cached_api.clean_datacached_objects()
    leaf_api.clean_leaves_objects()
    navigation_api.clean_navigation_objects()

    # Clear real caches
    leaf_cache.clear()
    html_tree_cache.clear()
    navigation_cache.clear()
    branch_cache.clear()
    link_cache.clear()

    message = Message(messages.SUCCESS, "Cached objects deleted with success.")
    return HttpResponse(
        json.dumps({
            "message": message.message,
            "tags": message.tags
        }),
        content_type="application/json",
    )
Пример #16
0
 def test_multiple_posts(self):
     """
     Tests that messages persist properly when multiple POSTs are made
     before a GET.
     """
     settings.MESSAGE_LEVEL = constants.DEBUG
     data = {
         'messages': ['Test message %d' % x for x in xrange(10)],
     }
     show_url = reverse('django.contrib.messages.tests.urls.show')
     messages = []
     for level in ('debug', 'info', 'success', 'warning', 'error'):
         messages.extend(
             [Message(self.levels[level], msg) for msg in data['messages']])
         add_url = reverse('django.contrib.messages.tests.urls.add',
                           args=(level, ))
         self.client.post(add_url, data)
     response = self.client.get(show_url)
     self.assertTrue('messages' in response.context)
     self.assertEqual(list(response.context['messages']), messages)
     for msg in data['messages']:
         self.assertContains(response, msg)
Пример #17
0
def save_form(request):
    """Save the current form in data base. Converts it to XML format first.

    Args:
        request:

    Returns:

    """
    try:
        # get curate data structure
        curate_data_structure_id = request.POST["id"]
        curate_data_structure = curate_data_structure_api.get_by_id(
            curate_data_structure_id, request.user)

        # generate xml data
        xml_data = render_xml(
            request, curate_data_structure.data_structure_element_root)

        # update curate data structure data
        curate_data_structure.form_string = xml_data

        # save data structure
        curate_data_structure_api.upsert(curate_data_structure, request.user)

        # add success message
        message = Message(
            messages.SUCCESS,
            get_form_label().capitalize() + " saved with success.")

        return HttpResponse(
            json.dumps({
                "message": message.message,
                "tags": message.tags
            }),
            content_type="application/json",
        )
    except Exception as e:
        return HttpResponseBadRequest(escape(str(e)))
Пример #18
0
 def test_full_request_response_cycle(self):
     """
     With the message middleware enabled, tests that messages are properly
     stored and then retrieved across the full request/redirect/response
     cycle.
     """
     settings.MESSAGE_LEVEL = constants.DEBUG
     data = {
         'messages': ['Test message %d' % x for x in xrange(10)],
     }
     show_url = reverse('django.contrib.messages.tests.urls.show')
     for level in ('debug', 'info', 'success', 'warning', 'error'):
         add_url = reverse('django.contrib.messages.tests.urls.add',
                           args=(level,))
         response = self.client.post(add_url, data, follow=True)
         self.assertRedirects(response, show_url)
         self.assertTrue('messages' in response.context)
         messages = [Message(self.levels[level], msg) for msg in
                                                      data['messages']]
         self.assertEqual(list(response.context['messages']), messages)
         for msg in data['messages']:
             self.assertContains(response, msg)
Пример #19
0
 def encode_decode(self, *args, **kwargs):
     storage = self.get_storage()
     message = Message(constants.DEBUG, *args, **kwargs)
     encoded = storage._encode(message)
     return storage._decode(encoded)
Пример #20
0
 def encode_decode(data):
     message = Message(constants.DEBUG, data)
     encoded = storage._encode(message)
     decoded = storage._decode(encoded)
     return decoded.message
Пример #21
0
 def get_existing_storage(self):
     return self.get_storage([
         Message(constants.INFO, 'Test message 1'),
         Message(constants.INFO, 'Test message 2', extra_tags='tag')
     ])
 def test_bootstrap_messages_with_safe_message(self):
     messages = [Message(DEFAULT_MESSAGE_LEVELS.INFO, mark_safe("Click <a href='https://www.github.com/'>here</a>"))]
     self.assertHTMLEqual(
         self.render("{% bootstrap_messages messages %}", {"messages": messages}),
         self._html(content="Click <a href='https://www.github.com/'>here</a>", css_class="alert-info"),
     )
Пример #23
0
 def get_existing_storage(self):
     return self.get_storage([
         Message(constants.INFO, "Test message 1"),
         Message(constants.INFO, "Test message 2", extra_tags="tag"),
     ])
Пример #24
0
 def add(self, level, message, extra_tags=''):
     self._loaded_data.append(Message(level, message, extra_tags=extra_tags))
Пример #25
0
 def add(self, level, message, extra_tags=''):
     obj_message = Message(level, message, extra_tags)
     if obj_message in self._loaded_messages:
         self._loaded_messages.remove(obj_message)
     super(MessageStorage, self).add(level, message, extra_tags='')
Пример #26
0
 def add_message(self, lvl, msg):
     self.append(Message(lvl, msg))
Пример #27
0
 def test_error_message_icon(self):
     self.assertEqual(message_icon(Message(messages.ERROR, "error")),
                      "pficon-error-circle-o")
Пример #28
0
 def test_warning_message_icon(self):
     self.assertEqual(
         message_icon(Message(messages.WARNING, "warning")),
         "pficon-warning-triangle-o",
     )
Пример #29
0
 def test_success_message_icon(self):
     self.assertEqual(message_icon(Message(messages.SUCCESS, "ok")),
                      "pficon-ok")
Пример #30
0
 def assert_message_exists(self, request, level, message):
     self.assertIn(Message(level=level, message=message),
                   messages.get_messages(request),
                   'Message matching criteria does not exist')
Пример #31
0
 def test_info_message_icon(self):
     self.assertEqual(message_icon(Message(messages.INFO, "info")),
                      "pficon-info")