def gen_entries(self):
"""Generate entries."""
for journal in self.journals:
for node in journal.node_set.all():
if node.type == Node.ENTRYDEADLINE:
entry = factory.make_entry(node.preset.forced_template)
entry.late = faker.boolean()
entry.save()
factory.make_grade(entry, self.users['Teacher'].pk, random.randint(1, 10), faker.boolean())
node.entry = entry
if journal.assignment.format.template_set.filter(archived=False, preset_only=False).count() > 0:
random_entries = random.randint(0, 8)
for _ in range(random_entries):
template = random.choice(journal.assignment.format.template_set.filter(archived=False,
preset_only=False))
entry = factory.make_entry(template)
entry.late = faker.boolean()
entry.save()
factory.make_grade(entry, self.users['Teacher'].pk, random.randint(1, 10), faker.boolean())
factory.make_node(journal, entry)
def test_get_comments(self):
"""Test update comment function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
comment = factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, self.rein_user, self.rein_pass)
update_dict = {'text': 'Bad!'}
test.api_patch_call(self, '/comments/' + str(comment.pk) + '/',
update_dict, login)
q_comment = Comment.objects.get(pk=comment.pk)
self.assertEquals(q_comment.text, 'Bad!')
def test_replace_result_no_url(self):
"""Hopefully doesnt crash."""
entry = factory.make_entry(
Template.objects.filter(name='Default Template')[0])
entry.published = True
entry.save()
factory.make_node(self.journal, entry)
self.journal.sourcedid = None
self.journal.grade_url = None
self.journal.save()
self.assertEqual(lti_grade.replace_result(self.journal), None)
def test_change_Entry_vle_coupling(self):
"""Hopefully doesnt crash."""
entry = factory.make_entry(
Template.objects.filter(name='Default Template')[0])
entry.published = True
entry.save()
factory.make_node(self.journal, entry)
lti_grade.change_Entry_vle_coupling(self.journal, Entry.GRADING)
for entry in Entry.objects.filter(
published=True, node__journal=self.journal).exclude(
vle_coupling=Entry.LINK_COMPLETE):
self.assertEqual(entry.vle_coupling, Entry.GRADING)
def test_check_if_need_VLE_publish_journals(self):
"""Hopefully doesnt crash."""
entry = factory.make_entry(
Template.objects.filter(name='Default Template')[0])
entry.published = True
entry.vle_coupling = Entry.GRADING
entry.save()
factory.make_node(self.journal, entry)
entry1 = factory.make_entry(
Template.objects.filter(name='Default Template')[0])
entry1.save()
factory.make_node(self.journal, entry1)
lti_grade.check_if_need_VLE_publish(self.assignment)
def update_journals(journals, preset, created):
"""Create or update the preset node in all relevant journals.
Arguments:
journals -- the journals to update.
preset -- the preset node to update the journals with.
created -- whether the preset node was newly created.
"""
if created:
for journal in journals:
factory.make_node(journal, None, preset.type, preset)
else:
for journal in journals:
journal.node_set.filter(preset=preset).update(type=preset.type)
def set_up_journal(assignment, template, user, n):
"""Set up a journal for an user with n entries.
Arguments:
assignment -- the assignment of the journal
template -- the entry template for the entries
user -- the user of the journal
n -- number of entries
Returns a journal with entries attached.
"""
journal = factory.make_journal(assignment, user)
for entry in set_up_entries(template, n):
factory.make_node(journal, entry)
return journal
def test_json(self):
"""Test is the to dict function works correctly."""
entry = factory.make_entry(self.template)
factory.make_node(self.j_rick_colloq, entry)
nodes = timeline.get_nodes(self.j_rick_colloq, self.u_rick)
self.assertEquals(len(nodes), 4)
self.assertEquals(nodes[0]['type'], 'd')
self.assertEquals(nodes[0]['entry'], None)
self.assertEquals(nodes[1]['type'], 'e')
self.assertEquals(nodes[2]['type'], 'a')
self.assertEquals(nodes[3]['type'], 'p')
self.assertEquals(nodes[3]['target'], 10)
def test_sorted(self):
"""Test is the sort function works."""
entry = factory.make_entry(self.template)
node = factory.make_node(self.j_rick_colloq, entry)
nodes = timeline.get_sorted_nodes(self.j_rick_colloq)
self.assertEquals(nodes[0].preset, self.deadlineentry)
self.assertEquals(nodes[1], node)
self.assertEquals(nodes[2].preset, self.progressnode)
def test_get_comments(self):
"""Test get comments function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, student_user, student_pass)
result = test.api_get_call(self,
'/comments/',
login,
params={
'entry_id': entry.pk
}).json()
self.assertEquals(result['comments'][0]['text'], 'Excellent!')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/comments/',
login,
status=403,
params={'entry_id': entry.pk})
test.api_get_call(self,
'/comments/',
login,
status=404,
params={'entry_id': self.not_found_pk})
test.test_unauthorized_api_get_call(self,
'/comments/',
params={'entry_id': entry.pk})
def test_journal_stats(self):
"""Test the journal stats functions in the serializer."""
template = factory.make_entry_template('template_test')
format = factory.make_format([template])
assign = factory.make_assignment("Colloq", "In de opdracht...1", self.teacher, format=format)
journal = factory.make_journal(assign, self.user)
entries = test.set_up_entries(template, 4)
for entry in entries:
factory.make_node(journal, entry)
journal = Journal.objects.get(user=self.user)
entries = utils.get_journal_entries(journal)
for i in range(len(entries)):
if i > 0:
entries[i].grade = 1
entries[i].published = True
entries[i].save()
self.assertEquals(utils.get_acquired_points(entries), 3)
self.assertEquals(utils.get_submitted_count(entries), 4)
self.assertEquals(utils.get_graded_count(entries), 3)
def gen_entries(self):
"""Generate entries."""
for journal in self.journals:
for node in journal.node_set.all():
if node.type == Node.ENTRYDEADLINE:
entry = factory.make_entry(node.preset.forced_template)
entry.late = faker.boolean()
entry.grade = random.randint(1, 10)
entry.save()
node.entry = entry
if journal.assignment.format.available_templates.count() > 0:
random_entries = random.randint(0, 8)
for _ in range(random_entries):
template = random.choice(journal.assignment.format.available_templates.all())
entry = factory.make_entry(template)
entry.late = faker.boolean()
entry.grade = random.randint(1, 10)
entry.save()
factory.make_node(journal, entry)
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
})
