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 })