def setUp(self):
"""Setup."""
self.u1 = factory.make_user("Zi", "pass", "*****@*****.**")
self.jf1 = factory.make_format()
self.jf2 = factory.make_format()
self.a1 = factory.make_assignment('tcolloq', 'description', format=self.jf1)
self.et1 = factory.make_entry_template('temp1')
self.et2 = factory.make_entry_template('temp2')
self.f1 = factory.make_field(self.et1, "test0", "1")
self.f2 = factory.make_field(self.et1, "test2", "2")
self.f3 = factory.make_field(self.et2, "test1", "1")
self.j1 = factory.make_journal(self.a1, self.u1)
self.e1 = factory.make_entry(self.et1)
self.e2 = factory.make_entry(self.et2)
self.c1 = factory.make_content(self.e1, "testcontent1", self.f1)
self.c2 = factory.make_content(self.e1, "testcontent2", self.f2)
self.c3 = factory.make_content(self.e2, "testcontent3", self.f3)
self.jf1.available_templates.add()
self.jf2.available_templates.add()
self.usr = factory.make_user('teun', '1234', email='*****@*****.**', lti_id='a')
self.crs = factory.make_course('test course please ignore', 'XXXX', startdate=datetime.date.today())
def gen_content(self):
"""Generate content for an entry."""
for journal in self.journals:
for node in journal.node_set.all():
if node.type == Node.ENTRY or node.type == Node.ENTRYDEADLINE:
if node.entry is None:
continue
template = node.entry.template
for field in template.field_set.all():
if field.type in [Field.TEXT, Field.RICH_TEXT]: # Files requires the actual file...
if "Requested Points" in field.title:
factory.make_content(node.entry, str(random.randint(1, 3)), field)
else:
factory.make_content(node.entry, faker.catch_phrase(), field)
def test_foreignkeys(self):
"""Test the foreign keys in the database."""
user_test = factory.make_user('lers', 'lers123', '*****@*****.**', '123456')
course_test = factory.make_course('tname', 'XXXX', datetime.date.today())
factory.make_format()
template = factory.make_entry_template("some_template")
entr_test = factory.make_entry(template)
field = factory.make_field(template, "test1", "1")
factory.make_content(entr_test, "data", field)
course_test.author = user_test
ass_test = factory.make_assignment(name='tcolloq', description='description')
ass_test.courses.add(course_test)
journ_test = factory.make_journal(user=user_test, assignment=ass_test)
self.assertEquals(entr_test.template.pk, template.pk)
self.assertEquals(journ_test.user.pk, user_test.pk)
self.assertEquals(journ_test.assignment.pk, ass_test.pk)
self.assertEquals(course_test.author.pk, user_test.pk)
def create(self, request):
"""Create a new entry.
Deletes remaining temporary user files if successful.
Arguments:
request -- the request that was send with
journal_id -- the journal id
template_id -- the template id to create the entry with
node_id -- optional: the node to bind the entry to (only for entrydeadlines)
content -- the list of {tag, data} tuples to bind data to a template field.
"""
journal_id, template_id, content_list = utils.required_params(
request.data, "journal_id", "template_id", "content")
node_id, = utils.optional_params(request.data, "node_id")
journal = Journal.objects.get(pk=journal_id, user=request.user)
assignment = journal.assignment
template = Template.objects.get(pk=template_id)
request.user.check_permission('can_have_journal', assignment)
if assignment.is_locked():
return response.forbidden(
'The assignment is locked, entries can no longer be edited/changed.'
)
if journal.needs_lti_link():
return response.forbidden(journal.outdated_link_warning_msg)
# Check if the template is available
if not (node_id or assignment.format.template_set.filter(
archived=False, preset_only=False, pk=template.pk).exists()):
return response.forbidden('Entry template is not available.')
entry_utils.check_fields(template, content_list)
# Node specific entry
if node_id:
node = Node.objects.get(pk=node_id, journal=journal)
entry = entry_utils.add_entry_to_node(node, template)
# Template specific entry
else:
entry = factory.make_entry(template)
node = factory.make_node(journal, entry)
for content in content_list:
field_id, = utils.required_typed_params(content, (int, 'id'))
data, = utils.required_params(content, 'data')
field = Field.objects.get(pk=field_id)
created_content = factory.make_content(node.entry, data, field)
if field.type in field.FILE_TYPES: # Image, file or PDF
user_file = file_handling.get_temp_user_file(
request.user, assignment, content['data'])
if user_file is None and field.required:
node.entry.delete()
# If there is a newly created node, delete that as well
if not node_id:
node.delete()
return response.bad_request(
'One of your files was not correctly uploaded, please try again.'
)
elif user_file:
file_handling.make_permanent_file_content(
user_file, created_content, node)
# Notify teacher on new entry
if (node.journal.sourcedid
and node.entry.vle_coupling == Entry.NEED_SUBMISSION):
lti_tasks.needs_grading.delay(node.pk)
# Delete old user files
file_handling.remove_temp_user_files(request.user)
return response.created({
'added':
entry_utils.get_node_index(journal, node, request.user),
'nodes':
timeline.get_nodes(journal, request.user),
'entry':
serialize.EntrySerializer(entry, context={
'user': request.user
}).data
})
def partial_update(self, request, *args, **kwargs):
"""Update an existing entry.
Arguments:
request -- request data
data -- the new data for the course
pk -- assignment ID
Returns:
On failure:
unauthorized -- when the user is not logged in
not found -- when the entry does not exist
forbidden -- User not allowed to edit this entry
unauthorized -- when the user is unauthorized to edit the entry
bad_request -- when there is invalid data in the request
On success:
success -- with the new entry data
"""
content_list, = utils.required_typed_params(request.data,
(list, 'content'))
entry_id, = utils.required_typed_params(kwargs, (int, 'pk'))
entry = Entry.objects.get(pk=entry_id)
graded = entry.is_graded()
journal = entry.node.journal
assignment = journal.assignment
if assignment.is_locked():
return response.forbidden(
'The assignment is locked, entries can no longer be edited/changed.'
)
request.user.check_permission('can_have_journal', assignment)
if not (journal.user == request.user or request.user.is_superuser):
return response.forbidden(
'You are not allowed to edit someone else\'s entry.')
if graded:
return response.bad_request(
'You are not allowed to edit graded entries.')
if entry.is_locked():
return response.bad_request(
'You are not allowed to edit locked entries.')
if journal.needs_lti_link():
return response.forbidden(journal.outdated_link_warning_msg)
# Check for required fields
entry_utils.check_fields(entry.template, content_list)
# Attempt to edit the entries content.
for content in content_list:
field_id, = utils.required_typed_params(content, (int, 'id'))
data, = utils.required_params(content, 'data')
field = Field.objects.get(pk=field_id)
old_content = entry.content_set.filter(field=field)
if old_content.exists():
old_content = old_content.first()
if old_content.field.pk != field_id:
return response.bad_request(
'The given content does not match the accompanying field type.'
)
if not data:
old_content.delete()
continue
entry_utils.patch_entry_content(request.user, entry,
old_content, field, data,
assignment)
# If there was no content in this field before, create new content with the new data.
# This can happen with non-required fields, or when the given data is deleted.
else:
factory.make_content(entry, data, field)
file_handling.remove_temp_user_files(request.user)
return response.success({
'entry':
serialize.EntrySerializer(entry, context={
'user': request.user
}).data
})