def post(self, request, app_name, command):
instance = get_command_instance(app_name, command)
# handle from AdminCommand if has view handler
if hasattr(instance, "view"):
return instance.view(request=request, app_name=app_name, command=command)
form = instance.Form(request.POST)
context = instance.init_context(request=request, app_name=app_name, command=command)
context["title"] = mark_safe(instance.name if instance.name else "%s" % command)
context["app_name"] = app_name
context["form"] = form
if form.is_valid():
args, options = instance.get_command_arguments(forms_data=form.cleaned_data)
output = StringIO()
extra_tags = ""
try:
call_command(command, stdout=output, no_color=True, *args, **options)
except Exception as e:
output.write(traceback.format_exc())
output.seek(0)
extra_tags = "error"
message = colourstrip(output.getvalue().replace("\n", '<br/>')) if output.getvalue() else "Done"
context["messages"] = [
Message(level=0, extra_tags=extra_tags, message=message)]
return HttpResponse(render(request, instance.template, context=context))
context["messages"] = [Message(level=0, extra_tags="error", message="Invalid form data")]
return HttpResponse(render(request, instance.template, context=context))
def test_multiple_messages(self):
test_messages = [
Message(constants.DEBUG, 'some debug message'),
Message(constants.INFO, 'some info message')
]
expected = {
'messages': [{
'text': 'some debug message',
'tags': LEVEL_TAGS[constants.DEBUG]
}, {
'text': 'some info message',
'tags': LEVEL_TAGS[constants.INFO]
}]
}
self.assertEqual(messages(test_messages), expected)
test_messages = [
Message(constants.DEBUG, '[\'some debug message\']'),
Message(constants.INFO, '[\'some info message\']')
]
expected = {
'messages': [{
'text': 'some debug message',
'tags': LEVEL_TAGS[constants.DEBUG]
}, {
'text': 'some info message',
'tags': LEVEL_TAGS[constants.INFO]
}]
}
self.assertEqual(messages(test_messages), expected)
def test_add_message_suggest_caslogout(self):
expected_msg_base_str = (
"To logout of The Provider, please close your browser, or visit "
"this <a href=\"/accounts/theid/logout/?{}\">link</a>.")
# Defaults.
req1 = self.request
self.provider.add_message_suggest_caslogout(req1)
expected_msg1 = Message(
messages.INFO,
expected_msg_base_str.format(urlencode({'next': '/test/'})),
)
self.assertIn(expected_msg1, get_messages(req1))
# Custom arguments.
req2 = self._get_request()
self.provider.add_message_suggest_caslogout(req2,
next_page='/redir/',
level=messages.WARNING)
expected_msg2 = Message(
messages.WARNING,
expected_msg_base_str.format(urlencode({'next': '/redir/'})),
)
self.assertIn(expected_msg2, get_messages(req2))
def test_eq(self):
msg_1 = Message(constants.INFO, 'Test message 1')
msg_2 = Message(constants.INFO, 'Test message 2')
msg_3 = Message(constants.WARNING, 'Test message 1')
self.assertEqual(msg_1, msg_1)
self.assertEqual(msg_1, mock.ANY)
self.assertNotEqual(msg_1, msg_2)
self.assertNotEqual(msg_1, msg_3)
self.assertNotEqual(msg_2, msg_3)
def test_bootstrap_messages_with_other_levels(self):
messages = [Message(DEFAULT_MESSAGE_LEVELS.INFO, "hello")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello", css_class="alert-info"),
)
messages = [Message(999, "hello")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello", css_class="alert-info"),
)
def test_bootstrap_messages(self):
messages = [Message(DEFAULT_MESSAGE_LEVELS.WARNING, "hello")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello", css_class="alert-warning"),
)
messages = [Message(DEFAULT_MESSAGE_LEVELS.ERROR, "hello")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello", css_class="alert-danger"),
)
def test_bootstrap_messages_with_other_content(self):
messages = [Message(DEFAULT_MESSAGE_LEVELS.ERROR, "hello http://example.com")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello http://example.com", css_class="alert-danger"),
)
messages = [Message(DEFAULT_MESSAGE_LEVELS.ERROR, "hello\nthere")]
self.assertHTMLEqual(
self.render("{% bootstrap_messages messages %}", {"messages": messages}),
self._html(content="hello there", css_class="alert-danger"),
)
def edit_record(request):
""" Edit a record.
Args:
request:
Returns:
"""
try:
data = data_api.get_by_id(request.POST['id'], request.user)
except DoesNotExist:
message = Message(
messages.ERROR, "It seems a " + get_data_label() +
" is missing. Please refresh the page.")
return HttpResponseBadRequest(json.dumps({
'message': message.message,
'tags': message.tags
}),
content_type='application/json')
# Check if the data is locked
if lock_api.is_object_locked(data.id, request.user):
message = Message(
messages.ERROR,
"The " + get_data_label() + " is locked. You can't edit it.")
return HttpResponseBadRequest(json.dumps({
'message': message.message,
'tags': message.tags
}),
content_type='application/json')
try:
# Check if a curate data structure already exists
curate_data_structure = curate_data_structure_api.get_by_data_id(
data.id)
except DoesNotExist:
# Create a new curate data structure
curate_data_structure = CurateDataStructure(
user=str(request.user.id),
template=str(data.template.id),
name=data.title,
form_string=data.xml_content,
data=data)
curate_data_structure = curate_data_structure_api.upsert(
curate_data_structure)
except Exception, e:
message = Message(messages.ERROR, "A problem occurred while editing.")
return HttpResponseBadRequest(json.dumps({
'message': message.message,
'tags': message.tags
}),
content_type='application/json')
def process_messages(self, obj):
if isinstance(obj, list) and obj:
if obj[0] == MessageEncoder.message_key:
if len(obj) == 3:
# Compatibility with previously-encoded messages
return Message(*obj[1:])
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 dict((key, self.process_messages(value))
for key, value in six.iteritems(obj))
return obj
def core_cache_all_files(request):
"""Function that cache all files under the selected node.
Args:
request:
Returns:
"""
try:
# cache all the files from the current node
root_node_id = request.POST.get("node_id", None)
root_node = Navigation.get_by_id(root_node_id)
active_ontology = query_ontology_api.get_active()
# get the navigation from the cache
nav_key = str(active_ontology.id)
# get id of the navigation root
if nav_key in navigation_cache:
navigation = navigation_cache.get(nav_key)
nav_root_id = navigation.id
dico_list = {}
for navigation_id in root_node.children:
leaves_nodes = []
# Get all children leaves from the node
get_leafs_nodes(navigation_id, leaves_nodes)
dico_list[navigation_id] = leaves_nodes
# Cache all includes files under the node
if dico_list:
for k, v in list(dico_list.items()):
for leaf_id in v:
cache_docs_from_leaf(leaf_id, request, nav_root_id)
else:
cache_docs_from_leaf(root_node_id, request, nav_root_id)
message = Message(messages.SUCCESS, "Documents cached with success.")
return HttpResponse(
json.dumps({
"message": message.message,
"tags": message.tags
}),
content_type="application/json",
)
except:
message = Message(messages.ERROR,
"An error occurred while caching the files.")
return HttpResponseBadRequest(message,
content_type="application/javascript")
def process_messages(self, obj):
if isinstance(obj, list) and obj:
if obj[0] == MessageEncoder.message_key:
if len(obj) == 3:
# Compatibility with previously-encoded messages
return Message(*obj[1:])
if obj[1]:
obj[3] = mark_safe(obj[3])
return Message(constants.DEFAULT_LEVELS[obj[2].upper()],
*obj[3:])
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
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>"))]
html = self.render("{% bootstrap_messages messages %}", {"messages": messages})
print(html)
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"),
)
def process_messages(self, obj):
if isinstance(obj, list) and obj:
if obj[0] == MessageEncoder.message_key:
return Message(*obj[1:])
return [self.process_messages(item) for item in obj]
if isinstance(obj, dict):
return dict([(key, self.process_messages(value))
for key, value in obj.iteritems()])
return obj
def test_default_hashing_algorithm(self):
messages = Message(constants.DEBUG, ['this', 'that'])
with self.settings(DEFAULT_HASHING_ALGORITHM='sha1'):
storage = self.get_storage()
encoded = storage._encode(messages)
decoded = storage._decode(encoded)
self.assertEqual(decoded, messages)
storage_default = self.get_storage()
self.assertNotEqual(encoded, storage_default._encode(messages))
def test_safedata(self):
"""
A message containing SafeData keeps its safe status when retrieved from
the message storage.
"""
storage = self.get_storage()
message = Message(constants.DEBUG, mark_safe("<b>Hello Django!</b>"))
set_session_data(storage, [message])
self.assertIsInstance(list(storage)[0].message, SafeData)
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
def test_error(self):
class TestView(MessageMixin, View):
def get(self, request):
self.messages.error("test")
return HttpResponse('OK')
request, _ = self.get_request_response(TestView.as_view())
msg = list(request._messages)
self.assertEqual(len(msg), 1)
self.assertEqual(msg[0], Message(messages.ERROR, 'test'))
def test_json_encoder_decoder(self):
"""
Tests that 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 xrange(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)
def test_error(self):
"""Messages should able to be set as ERROR"""
class TestView(MessageMixin, View):
def get(self, request):
self.messages.error("test")
return HttpResponse("OK")
request, _ = self.get_request_response(TestView.as_view())
msg = list(request._messages)
self.assertEqual(len(msg), 1)
self.assertEqual(msg[0], Message(messages.ERROR, "test"))
def test_message_on_logout(self):
"""
Message is sent to propose user to logout of CAS.
"""
r = self.client.post('/accounts/logout/')
r_messages = get_messages(r.wsgi_request)
expected_msg = Message(messages.WARNING, self.expected_msg_str)
self.assertIn(expected_msg, r_messages)
self.assertTemplateUsed(r, 'cas_account/messages/logged_out.txt')
def test_no_message_on_visit(self):
"""Clear out messages from django-allauth on sign up."""
user = self.make_user()
self.client.cookies["messages"] = CookieStorage(request=None)._encode(
[Message(messages.INFO, "Find me")])
with self.login(user):
response = self.get("core:start")
self.assertResponseNotContains("Find me", response)
assert response.cookies["messages"].value == ""
def test_set_level(self):
class TestView(MessageMixin, View):
def get(self, request):
self.messages.set_level(messages.WARNING)
self.messages.add_message(messages.SUCCESS, 'success')
self.messages.add_message(messages.WARNING, 'warning')
return HttpResponse('OK')
request, _ = self.get_request_response(TestView.as_view())
msg = list(request._messages)
self.assertEqual(msg, [Message(messages.WARNING, 'warning')])
def test_set_level(self):
"""Should be able to set message levels"""
class TestView(MessageMixin, View):
def get(self, request):
self.messages.set_level(messages.WARNING)
self.messages.add_message(messages.SUCCESS, "success")
self.messages.add_message(messages.WARNING, "warning")
return HttpResponse("OK")
request, _ = self.get_request_response(TestView.as_view())
msg = list(request._messages)
self.assertEqual(msg, [Message(messages.WARNING, "warning")])
def test_message_on_logout(self):
"""
Message is sent to propose user to logout of CAS.
"""
r = self.client.post('/accounts/logout/?next=/redir/')
r_messages = get_messages(r.wsgi_request)
expected_msg = Message(messages.WARNING, self.expected_msg_str)
self.assertIn(expected_msg, r_messages)
self.assertTemplateUsed(
r, 'socialaccount/messages/suggest_caslogout.html')
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()
value = encoder.encode(messages)
decoded_messages = json.loads(value, cls=MessageDecoder)
self.assertEqual(messages, decoded_messages)
def test_messages(self):
for tag in self.tags:
txt = f"some message with {repr(tag)}"
test_messages = [Message(tag, txt)]
self.assertEqual(
messages(test_messages),
{"messages": [{
"text": txt,
"tags": LEVEL_TAGS[tag]
}]}) # clean one
txt = f"['some dirty message with {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 test_multiple_messages(self):
test_messages = [
Message(constants.DEBUG, "some debug message"),
Message(constants.INFO, "some info message")
]
expected = {
"messages": [
{
"text": "some debug message",
"tags": LEVEL_TAGS[constants.DEBUG]
},
{
"text": "some info message",
"tags": LEVEL_TAGS[constants.INFO]
},
]
}
self.assertEqual(messages(test_messages), expected)
test_messages = [
Message(constants.DEBUG, "['some debug message']"),
Message(constants.INFO, "['some info message']"),
]
expected = {
"messages": [
{
"text": "some debug message",
"tags": LEVEL_TAGS[constants.DEBUG]
},
{
"text": "some info message",
"tags": LEVEL_TAGS[constants.INFO]
},
]
}
self.assertEqual(messages(test_messages), expected)
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
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
