def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) group = permissions.get_or_create_student_permissions() group.user_set.add(self.student_user) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) group = permissions.get_or_create_instructor_permissions() group.user_set.add(self.instructor_user) self.client.login(username=self.instructor_username, password=self.password) # populate test database self.course = Course(name='Bounty Hunting 101') self.course.save() self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term='before', enroll_key='4') self.group.save() self.student = Student(user=self.student_user, wwuid='9994141', labgroup=self.group) self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() # retrieve the view self.view_name = 'api:assignment-lc'
def test_student_list(self): """ Tests that students are properly listed. """ # add students to database Student(user=self.student_user, labgroup=self.group, wwuid='64').save() Student(user=self.instructor_user, labgroup=self.group, wwuid='12').save() # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response students = Student.objects.all() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['students'][0]['user'], students[0].user.id) self.assertEqual(response_body['students'][0]['labgroup'], students[0].labgroup.id) self.assertEqual(response_body['students'][0]['wwuid'], students[0].wwuid) self.assertEqual(response_body['students'][1]['user'], students[1].user.id) self.assertEqual(response_body['students'][1]['labgroup'], students[1].labgroup.id) self.assertEqual(response_body['students'][1]['wwuid'], students[1].wwuid)
def setUp(self): # create test users self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) group = permissions.get_or_create_instructor_permissions() group.user_set.add(self.instructor_user) group = permissions.get_or_create_student_permissions() group.user_set.add(self.student_user) self.client.login(username=self.student_username, password=self.password) # populate the database self.student = Student(labgroup=None, user=self.student_user, wwuid='1111111') self.student.save() self.instructor = Instructor(user=self.instructor_user, wwuid='2222222') self.instructor.save() self.course = Course(name='test name') self.course.save() self.labgroup = LabGroup(course=self.course, instructor=self.instructor, group_name='A', term='FALL2018', enroll_key='ABC') self.labgroup.save() # retrieve the view self.view_name = 'api:enroll'
def mutate(self, info, name, age): try: student = Student(name=name, age=age) student.save() return AddStudent(success=True) except: return AddStudent(success=False)
def post(self, request, format=None): serializer = StudentOtherSerializer(data=request.data) if serializer.is_valid(): student = Student(**serializer.data) student.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_user(user_id, login): user = Student.objects.filter(login=login) if user.exists(): return user[0] else: user = Student(user_id=user_id, login=login) logger.info(f"Student {login} created") user.save() return user
def test_matricule_is_immutable(self): """The student matricule cannot be edited""" Student.new_student({ 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001' }) alice = Student.get_by_id('X2010200001') alice.data['matricule'] += '1' self.assertRaises(AttributeError, alice.put)
def test_update_student(self): """the student data stay valide""" Student.new_student({ 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001' }) alice = Student.get_by_id('X2010200001') del alice.data['lastName'] self.assertRaises(ValidationError, alice.put)
def post(self, request): try: name = request.data['name'] age = request.data['age'] student = Student(name=name, age=age) student.save() return Response(status=HTTP_201_CREATED) except: return Response(status=HTTP_400_BAD_REQUEST)
def get_user(user_id): user = Student.objects.filter(user_id=user_id) if user.exists(): return user[0] else: res = client.get(f"/users/{user_id}") login = res.json()["login"] user = Student(user_id=user_id, login=login) user.save() logger.info(f"Student {login} created") return user
def post(self, request, format=None): form = self.form_class(data=request.data) if not form.is_valid(): raise ValueError("Invalid") serializer = StudentOtherSerializer(data=request.data) if serializer.is_valid(): student = Student(**serializer.data) student.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.error, status=status.HTTP_400_BAD_REQUEST)
def test_names_are_capitalized(self): alice = Student.new_student({ 'firstName': 'alice', 'lastName': 'smith', 'matricule': 'X2010200001' }) self.assertEqual('Alice', alice.first_name) self.assertEqual('Smith', alice.last_name) alice = Student.get_by_id('X2010200001') alice.data['lastName'] = 'taylor' alice.put() self.assertEqual('Taylor', alice.last_name)
def scrap(self, get_hash = None): cookie = urllib2.HTTPCookieProcessor() opener = urllib2.build_opener(cookie) urllib2.install_opener(opener) data = {} data['i_Login'] = self.username data['i_Senha'] = self.password data = urllib.urlencode(data) url = 'https://memphis.ulbranet.com.br/pls/ulbra24/AAWEB.login' url2 = 'https://memphis.ulbranet.com.br/aa/notas' opener.open(url, data) request = urllib2.Request(url2) response = urllib2.urlopen(request) soup = BeautifulSoup(response.read()) student = Student() student.course = soup.find("a", "active").contents[0].strip() student.name = soup.find("div", {"id": "cabprint_inf"}).contents[4].strip() for grade in soup.findAll("li", {"id": "li_notas"}): semester_obj = Semester(grade.find("a", "link").contents[0]) for discipline in grade.findAll("div", "notas-bloco"): i = 0 for total in discipline.findAll("div", "notas-texto"): value = total.parent.findAll("div", "notas-final")[i].contents[0].strip() value = value.replace("\n", "").replace("\t", "") grade_total_obj = Grade("Média", value) discipline_obj = Discipline(total.find("div", "notas-disciplina").contents[0].strip()) for partial in total.findAll("div", "notas-parciais"): grade_value = partial.b.contents[0].string.replace("\n", "").replace("\t", "").strip() grade_name = partial.contents[0].string.replace("\n", "").replace("\t", "").strip() grade_disc = Grade(str(grade_name), str(grade_value)) discipline_obj.grades.append(grade_disc) discipline_obj.grades.append(grade_total_obj) i += 1 semester_obj.disciplines.append(discipline_obj) student.semesters.append(semester_obj) if get_hash: try: student.hash = hashlib.sha1(obj2json(student)).hexdigest() except Exception, e: print e.message
def test_new_student(self): alice = Student.new_student({ 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001' }) self.assertEqual('X2010200001', alice.matricule) self.assertEqual('X2010200001', alice.key.id()) self.assertEqual('Alice', alice.first_name) self.assertEqual('Smith', alice.last_name) self.assertEqual('Smith, Alice', alice.full_name) self.assertEqual(None, alice.photo) alice = Student.get_by_id('X2010200001') self.assertTrue(alice)
def test_student_list_not_shown_to_students(self): """ Tests that students are not listed to other students. """ # login the student self.client.logout() self.client.login(username=self.student_username, password=self.password) # add students to database Student(user=self.student_user, labgroup=self.group, wwuid='64').save() Student(user=self.instructor_user, labgroup=self.group, wwuid='12').save() # request response = self.client.get(reverse(self.view_name)) # test response self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_validate_student(self): self.assertEqual( None, Student.validate( { 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001', 'photo': 'http://placehold.it/300x400&text=portrait' } ) ) self.assertRaises( ValidationError, Student.validate, { 'matricule': 'X2010200001' } ) self.assertRaises( ValidationError, Student.validate, { 'firstName': 'Alice', 'lastName': 'Smith', } )
def test_new_student_create_unique_student(self): Student.new_student({ 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001' }) self.assertRaises( AttributeError, Student.new_student, { 'firstName': 'Bob', 'lastName': 'Smith', 'matricule': 'X2010200001' # same matricule } ) alice = Student.get_by_id('X2010200001') self.assertEqual('Alice', alice.first_name)
def post(self, request): """ Enroll in a labgroup. """ # ensure all parameters are present in the request data for param in ('wwuid', 'labgroup', 'enroll_key'): if param not in request.data.keys(): return Response(status=status.HTTP_400_BAD_REQUEST) # load the labgroup from the database try: labgroup = LabGroup.objects.get(id=request.data['labgroup']) except LabGroup.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) # check enroll key if request.data['enroll_key'] != labgroup.enroll_key: return Response(status=status.HTTP_403_FORBIDDEN) # delete student if it exists try: student = Student.objects.get(user=request.user) student.delete() except Student.DoesNotExist: pass # validate student data in request student_data = { 'user': request.user.id, 'labgroup': labgroup.id, 'wwuid': request.data['wwuid'], } serializer = StudentSerializer(data=student_data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # create the student student = Student(user=request.user, labgroup=labgroup, wwuid=request.data['wwuid']) student.save() # add new student to the student group group = permissions.get_or_create_student_permissions() group.user_set.add(request.user) # return successful response return Response(status=status.HTTP_204_NO_CONTENT)
def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.client.login(username=self.student_username, password=self.password) # populate test database self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.course = Course(name='Bounty Hunting 101') self.course.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='4', group_name='Group A') self.group.save() self.student = Student(user=self.student_user, labgroup=self.group, wwuid='1111111') self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() self.assignment = Assignment( assignment_template=self.template, labgroup=self.group, open_date=datetime.now(timezone(settings.TIME_ZONE)), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) self.assignment.save() self.assignment_entry = AssignmentEntry(student=self.student, assignment=self.assignment) self.assignment_entry.save() # retrieve the view self.view_name = 'api:assignment-entry-submit'
def test_student_average_score(self): students = Student.ranked_by_average_score(self.teacher1.id) expected_students = [ "<Student: %s %s>" % (self.student1.first_name, self.student1.last_name), "<Student: %s %s>" % (self.student2.first_name, self.student2.last_name) ] self.assertQuerysetEqual(students, expected_students)
def post(self, request): statename = request.POST['statename'] collegename = request.POST['collegename'] hostelname = request.POST['hostelname'] branchname = request.POST['branchname'] studentname = request.POST['studentname'] studentrollno = request.POST['studentrollno'] studentemailid = request.POST['studentemailid'] studentpercentage = request.POST['studentpercentage'] studentbloodgp = request.POST['studentbloodgp'] studentyear = request.POST['studentyear'] studentroomno = request.POST['studentroomno'] candonateblood = request.POST['candonateblood'] print(statename + " \n" + collegename + " \n" + hostelname + " \n" + branchname + " \n" + studentname + " \n" + studentrollno + " \n" + studentemailid + " \n" + studentpercentage + " \n" + studentbloodgp + " \n" + studentyear + " \n" + studentroomno + " \n" + candonateblood) p = Student(statename=State.objects.get(statename=statename), collegename=College.objects.get(collegename=collegename), hostelname=Hostel.objects.get(hostelname=hostelname), branchname=Branch.objects.get(branchname=branchname), studentrollno=studentrollno, studentemailid=studentemailid, studentpercentage=studentpercentage, studentbloodgp=studentbloodgp, studentyear=studentyear, studentroomno=studentroomno, candonateblood=candonateblood) p.save() print(request.user.username) try: Postlogin.objects.get(username=request.user.username) except: Postlogin.objects.create(username=request.user.username) return render(request, "ui/profile.html")
def create(self, validated_data): password = validated_data['password'] re_password = validated_data['re_password'] if password != re_password: raise serializers.ValidationError( {'password': '******'}) student = Student( username=validated_data['username'], email=validated_data['email'], ) student.set_password(password) student.save() verification_token = random_token(16) from api.models import VerificationToken VerificationToken(student=student, token=verification_token, type=1).save() email_context = { 'token': verification_token, 'username': student.username, } sendemail(subject='Account Verification FIIMaterials', template='email_verification.html', context=email_context, email_to=[student.email]) return student
def student_register(request): if request.method == "POST": first_name = request.POST.get('first-name', "") last_name = request.POST.get('last-name', "") parent_option = request.POST.get('parent-option', "") parent = User.objects.get(id=parent_option) s = Student(first_name=first_name, last_name=last_name, parent=parent) s.save() s.generate_qrcode() return HttpResponseRedirect('/')
def setUp(self): # create test user with permissions and test student user self.instructor_username = '******' self.student_username_1 = 'test student 1' self.student_username_2 = 'test student 2' self.student_username_3 = 'test student 3' self.password = '******' self.student_user_1 = User.objects.create_user( username=self.student_username_1, password=self.password) self.student_user_2 = User.objects.create_user( username=self.student_username_2, password=self.password) self.student_user_3 = User.objects.create_user( username=self.student_username_3, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.instructor_user.user_permissions.add( Permission.objects.get(codename='change_student')) self.instructor_user.user_permissions.add( Permission.objects.get(codename='delete_student')) self.client.login(username=self.instructor_username, password=self.password) # populate database self.instructor = Instructor(user=self.instructor_user, wwuid='9999999') self.instructor.save() self.course = Course(name='test course') self.course.save() self.group_1 = LabGroup(course=self.course, instructor=self.instructor, term='never', enroll_key='6') self.group_1.save() self.group_2 = LabGroup(course=self.course, instructor=self.instructor, term='ever', enroll_key='8') self.group_2.save() self.student_1 = Student(user=self.student_user_1, labgroup=self.group_1, wwuid='1111111') self.student_1.save() self.student_2 = Student(user=self.student_user_2, labgroup=self.group_1, wwuid='2222222') self.student_2.save() self.student_3 = Student(user=self.student_user_3, labgroup=self.group_1, wwuid='3333333') self.student_3.save() # retrieve the view self.view_name = 'api:student-rud'
def setUp(self): super(TestStudentApi, self).setUp() self.request = webapp2.Request.blank('') self.request.META = {} self.request.META['REMOTE_ADDR'] = '1.2.3.4' self.app = TestApp(main.app) self.alice = Student.new_student({ 'firstName': 'Alice', 'lastName': 'Smith', 'matricule': 'X2010200001' }) # make sure data will be visible in next query ndb.get_multi( [ self.alice.key ], use_cache=False )
def setUp(self): course_a = Course( name=f'Course A', description='', start_date=datetime.date.today(), end_date=datetime.date.today() + datetime.timedelta(days=1), ) course_b = Course( name=f'Course B', description='', start_date=datetime.date.today(), end_date=datetime.date.today() + datetime.timedelta(days=1), ) course_a.save() course_b.save() student_a = Student(first_name="Student A", last_name="aaa", email="*****@*****.**") student_b = Student(first_name="Student B", last_name="bbb", email="*****@*****.**") student_a.save() student_b.save() participants = [ CourseParticipant(course=course_a, student=student_a, completed=True), CourseParticipant(course=course_b, student=student_b, completed=False), CourseParticipant(course=course_a, student=student_b, completed=True), ] CourseParticipant.objects.bulk_create(participants)
class AssignmentLCTest(APITestCase): """ Test cases for list and create requests on AssignmentLCView. """ def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) group = permissions.get_or_create_student_permissions() group.user_set.add(self.student_user) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) group = permissions.get_or_create_instructor_permissions() group.user_set.add(self.instructor_user) self.client.login(username=self.instructor_username, password=self.password) # populate test database self.course = Course(name='Bounty Hunting 101') self.course.save() self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term='before', enroll_key='4') self.group.save() self.student = Student(user=self.student_user, wwuid='9994141', labgroup=self.group) self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() # retrieve the view self.view_name = 'api:assignment-lc' def test_assignment_create(self): """ Tests that an assignment is properly created. """ # request request_body = { 'assignment_template': self.template.id, 'labgroup': self.group.id, 'open_date': '2013-12-12T22:22:22Z', 'close_date': '2014-12-12T22:22:22Z', } response = self.client.post(reverse(self.view_name), request_body) response_body = json.loads(response.content.decode('utf-8')) # test database assignment = Assignment.objects.first() self.assertEqual(assignment.assignment_template.id, request_body['assignment_template']) self.assertEqual(assignment.labgroup.id, request_body['labgroup']) self.assertEqual( assignment.open_date.replace(tzinfo=None), datetime.strptime(request_body['open_date'], '%Y-%m-%dT%H:%M:%SZ')) self.assertEqual( assignment.close_date.replace(tzinfo=None), datetime.strptime(request_body['close_date'], '%Y-%m-%dT%H:%M:%SZ')) # test response self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response_body['assignment_template'], request_body['assignment_template']) self.assertEqual(response_body['labgroup'], request_body['labgroup']) self.assertEqual(response_body['open_date'], request_body['open_date']) self.assertEqual(response_body['close_date'], request_body['close_date']) def test_assignment_create_check_valid_dates(self): """ Tests that an assignment is not created when the open and close dates are incompatible. """ # get current time current_time = datetime.now(timezone(settings.TIME_ZONE)) # request request_body = { 'assignment_template': self.template.id, 'labgroup': self.group.id, 'open_date': (current_time + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'close_date': current_time.strftime('%Y-%m-%dT%H:%M:%SZ'), } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # test database self.assertFalse(Assignment.objects.exists()) def test_assignment_create_template_course_incompatible(self): """ Tests that an assignment is not created when the assignment template doesn't belong to a shared course. """ # create different course course = Course(name='other course') course.save() # create different template template = AssignmentTemplate(course=course, name='other template') template.save() # request current_time = datetime.now(timezone(settings.TIME_ZONE)) request_body = { 'assignment_template': template.id, 'labgroup': self.group.id, 'open_date': (current_time - timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), 'close_date': (current_time + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%SZ'), } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # test database self.assertFalse(Assignment.objects.exists()) def test_assignment_list_instructor(self): """ Tests that assignments are properly listed. """ # add assignments to database current_time = datetime.now(timezone(settings.TIME_ZONE)) Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)).save() Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)).save() # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response assignments = Assignment.objects.all() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response_body['assignments'][0]['assignment_template'], assignments[0].assignment_template.id) self.assertEqual(response_body['assignments'][0]['name'], assignments[0].assignment_template.name) self.assertEqual(response_body['assignments'][0]['labgroup'], assignments[0].labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][0]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[0].open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][0]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[0].close_date.replace(tzinfo=None)) self.assertEqual( response_body['assignments'][1]['assignment_template'], assignments[1].assignment_template.id) self.assertEqual(response_body['assignments'][1]['name'], assignments[1].assignment_template.name) self.assertEqual(response_body['assignments'][1]['labgroup'], assignments[1].labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][1]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[1].open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][1]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[1].close_date.replace(tzinfo=None)) def test_assignment_list_instructor_does_not_own(self): """ Tests that assignments are properly listed. """ # create other instructor and labgroup user = User.objects.create_user(username='******', password='******') instructor = Instructor(wwuid='2027616', user=user) instructor.save() labgroup = LabGroup(course=self.course, instructor=instructor, term=get_current_term(), enroll_key='ABC') labgroup.save() # add assignments to database current_time = datetime.now(timezone(settings.TIME_ZONE)) assignment_1 = Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)) assignment_1.save() Assignment(assignment_template=self.template, labgroup=labgroup, open_date=current_time, close_date=current_time + timedelta(days=1)).save() # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response_body['assignments']), 1) self.assertEqual( response_body['assignments'][0]['assignment_template'], assignment_1.assignment_template.id) self.assertEqual(response_body['assignments'][0]['name'], assignment_1.assignment_template.name) self.assertEqual(response_body['assignments'][0]['labgroup'], assignment_1.labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][0]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignment_1.open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][0]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignment_1.close_date.replace(tzinfo=None)) def test_assignment_list_student(self): """ Tests that assignments are properly listed. """ # login the student self.client.logout() self.client.login(username=self.student_username, password=self.password) # add assignments to database current_time = datetime.now(timezone(settings.TIME_ZONE)) Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)).save() Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)).save() # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response assignments = Assignment.objects.all() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response_body['assignments'][0]['assignment_template'], assignments[0].assignment_template.id) self.assertEqual(response_body['assignments'][0]['name'], assignments[0].assignment_template.name) self.assertEqual(response_body['assignments'][0]['labgroup'], assignments[0].labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][0]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[0].open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][0]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[0].close_date.replace(tzinfo=None)) self.assertEqual( response_body['assignments'][1]['assignment_template'], assignments[1].assignment_template.id) self.assertEqual(response_body['assignments'][1]['name'], assignments[1].assignment_template.name) self.assertEqual(response_body['assignments'][1]['labgroup'], assignments[1].labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][1]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[1].open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][1]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignments[1].close_date.replace(tzinfo=None)) def test_assignment_list_student_different_labgroup(self): """ Tests that assignments are not listed if they are for a different labgroup. """ # login the student self.client.logout() self.client.login(username=self.student_username, password=self.password) # create other labgroup labgroup = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='ABC') labgroup.save() # add assignments to database current_time = datetime.now(timezone(settings.TIME_ZONE)) assignment_1 = Assignment(assignment_template=self.template, labgroup=self.group, open_date=current_time, close_date=current_time + timedelta(days=1)) assignment_1.save() Assignment(assignment_template=self.template, labgroup=labgroup, open_date=current_time, close_date=current_time + timedelta(days=1)).save() # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response_body['assignments']), 1) self.assertEqual( response_body['assignments'][0]['assignment_template'], assignment_1.assignment_template.id) self.assertEqual(response_body['assignments'][0]['name'], assignment_1.assignment_template.name) self.assertEqual(response_body['assignments'][0]['labgroup'], assignment_1.labgroup.id) self.assertEqual( datetime.strptime(response_body['assignments'][0]['open_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignment_1.open_date.replace(tzinfo=None)) self.assertEqual( datetime.strptime(response_body['assignments'][0]['close_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignment_1.close_date.replace(tzinfo=None))
class StudentRUDTest(APITestCase): """ Test cases for retrieve, update, and destroy requests on StudentRUDView. """ def setUp(self): # create test user with permissions and test student user self.instructor_username = '******' self.student_username_1 = 'test student 1' self.student_username_2 = 'test student 2' self.student_username_3 = 'test student 3' self.password = '******' self.student_user_1 = User.objects.create_user( username=self.student_username_1, password=self.password) self.student_user_2 = User.objects.create_user( username=self.student_username_2, password=self.password) self.student_user_3 = User.objects.create_user( username=self.student_username_3, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.instructor_user.user_permissions.add( Permission.objects.get(codename='change_student')) self.instructor_user.user_permissions.add( Permission.objects.get(codename='delete_student')) self.client.login(username=self.instructor_username, password=self.password) # populate database self.instructor = Instructor(user=self.instructor_user, wwuid='9999999') self.instructor.save() self.course = Course(name='test course') self.course.save() self.group_1 = LabGroup(course=self.course, instructor=self.instructor, term='never', enroll_key='6') self.group_1.save() self.group_2 = LabGroup(course=self.course, instructor=self.instructor, term='ever', enroll_key='8') self.group_2.save() self.student_1 = Student(user=self.student_user_1, labgroup=self.group_1, wwuid='1111111') self.student_1.save() self.student_2 = Student(user=self.student_user_2, labgroup=self.group_1, wwuid='2222222') self.student_2.save() self.student_3 = Student(user=self.student_user_3, labgroup=self.group_1, wwuid='3333333') self.student_3.save() # retrieve the view self.view_name = 'api:student-rud' def test_student_retrieve(self): """ Tests that a student is properly retrieved. """ # request response = self.client.get( reverse(self.view_name, args=[self.student_2.id])) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['user'], self.student_2.user.id) self.assertEqual(response_body['labgroup'], self.student_2.labgroup.id) self.assertEqual(response_body['wwuid'], self.student_2.wwuid) def test_student_update(self): """ Tests that a student is properly updated. """ # modify values request_body = { 'user': self.student_user_2.id, 'labgroup': self.group_2.id, 'wwuid': '8888888', } # request response = self.client.put( reverse(self.view_name, args=[self.student_2.id]), request_body) response_body = json.loads(response.content.decode('utf-8')) # test database student = Student.objects.filter(user=self.student_user_2).first() self.assertEqual(student.user.id, request_body['user']) self.assertEqual(student.labgroup.id, request_body['labgroup']) self.assertEqual(student.wwuid, request_body['wwuid']) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['user'], request_body['user']) self.assertEqual(response_body['labgroup'], request_body['labgroup']) self.assertEqual(response_body['wwuid'], request_body['wwuid']) def test_student_destroy(self): """ Tests that a student is properly destroyed. """ # request response = self.client.delete( reverse(self.view_name, args=[self.student_2.id])) # test database students = Student.objects.all() self.assertTrue(self.student_1 in students) self.assertTrue(self.student_2 not in students) self.assertTrue(self.student_3 in students) # test response self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
class EnrollTest(APITestCase): """ Test cases for POST requests on EnrollView. """ def setUp(self): # create test users self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) group = permissions.get_or_create_instructor_permissions() group.user_set.add(self.instructor_user) group = permissions.get_or_create_student_permissions() group.user_set.add(self.student_user) self.client.login(username=self.student_username, password=self.password) # populate the database self.student = Student(labgroup=None, user=self.student_user, wwuid='1111111') self.student.save() self.instructor = Instructor(user=self.instructor_user, wwuid='2222222') self.instructor.save() self.course = Course(name='test name') self.course.save() self.labgroup = LabGroup(course=self.course, instructor=self.instructor, group_name='A', term='FALL2018', enroll_key='ABC') self.labgroup.save() # retrieve the view self.view_name = 'api:enroll' def test_enroll(self): """ Tests that a labgroup can be properly enrolled in. """ # request request_body = { 'wwuid': self.student.wwuid, 'labgroup': self.labgroup.id, 'enroll_key': self.labgroup.enroll_key } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) # test database self.assertEqual(Student.objects.first().user, self.student_user) self.assertEqual(Student.objects.first().labgroup, self.labgroup) self.assertEqual(Student.objects.first().wwuid, self.student.wwuid) def test_enroll_bad_labgroup(self): """ Tests that entering a bad labgroup is properly handled. """ # request request_body = { 'wwuid': self.student.wwuid, 'labgroup': 0, 'enroll_key': self.labgroup.enroll_key } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) # test database self.assertEqual(Student.objects.first().labgroup, None) def test_enroll_bad_key(self): """ Tests that a labgroup is not enrolled in with a bad key. """ # request request_body = { 'wwuid': self.student.wwuid, 'labgroup': self.labgroup.id, 'enroll_key': '' } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # test database self.assertEqual(Student.objects.first().labgroup, None) def test_missing_parameters(self): """ Tests that a missing parameter causes the request to do nothing. """ # request request_body = { 'wwuid': self.student.wwuid, 'enroll_key': self.labgroup.enroll_key } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # test database self.assertEqual(Student.objects.first().labgroup, None) def test_invalid_student(self): """ Tests that entering invalid student does nothing. """ # request request_body = { 'wwuid': '123456789', # too long 'labgroup': self.labgroup.id, 'enroll_key': self.labgroup.enroll_key } response = self.client.post(reverse(self.view_name), request_body) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # test database self.assertEqual(len(Student.objects.all()), 0) def test_enroll_status(self): """ Tests that the enrollment status of a user can be retrieved. """ # enroll request request_body = { 'user': self.student_user, 'student': self.student, } self.client.post(reverse(self.view_name), request_body) # enroll status request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['user']['username'], self.student_user.username) self.assertEqual(response_body['user']['email'], self.student_user.email) self.assertEqual(response_body['user']['first_name'], self.student_user.first_name) self.assertEqual(response_body['user']['last_name'], self.student_user.last_name) self.assertEqual(response_body['student']['pk'], self.student.id) self.assertEqual(response_body['student']['labgroup'], self.student.labgroup) self.assertEqual(response_body['student']['user'], self.student.user.id) self.assertEqual(response_body['student']['wwuid'], self.student.wwuid) def test_enroll_status_not_enrolled(self): """ Tests that no enrollment status is retrieved for an un-enrolled user. """ # un-enroll user self.student.delete() # enroll status request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['user']['username'], self.student_user.username) self.assertEqual(response_body['user']['email'], self.student_user.email) self.assertEqual(response_body['user']['first_name'], self.student_user.first_name) self.assertEqual(response_body['user']['last_name'], self.student_user.last_name) self.assertEqual(response_body['student'], None)
def get(self, request, pk): students = Student.ranked_by_average_score(pk) return Response(StudentRankSerializer(students, many=True).data)
def create_account (request): if request.method == "POST": print("POSTPOSTPOSTPOSTPOSTPOSTPOSTPOST") form = UserCreationForm(request.POST) print(form.is_valid()) print(request.POST) cleaned_data = form.clean() if cleaned_data.get('password') == cleaned_data.get('confirm_password'): token = Token.objects.get(token=cleaned_data.get('token')) username = token.username email = token.email first_name = token.first_name last_name = token.last_name isStudent = token.isStudent grade = token.grade git = cleaned_data.get('git') password = cleaned_data.get('password') user = User.objects.create_user(username=username, email=email, first_name=first_name, last_name=last_name, password=password) user.save() g, created = Group.objects.get_or_create(name='teachers') if isStudent: profile = Student(user=user, git=git, grade=grade, ion_user=username) else: profile = Teacher(user=user, git=git, ion_user=username) group = Group.objects.get(name='teachers') user.groups.add(group) profile.save() token.delete() print (user) messages.success(request, "Your SkoolOS account has successfully been created") return redirect(f'/login/?username={username}') else: print(form.errors) Token.objects.get(token=request.GET.get('token')).delete() messages.warning(request, "Passwords did not match!") return redirect('/register/') if request.method == "GET" and Token.objects.filter(token=request.GET.get('token')).count() == 1: print("GETGETGETGETGETGET") token = Token.objects.get(token=request.GET.get('token')) username = token.username email = token.email first_name = token.first_name last_name = token.last_name isStudent = token.isStudent grade = token.grade initial = { 'username': username, 'email': email, 'first_name': first_name, 'last_name': last_name, 'grade': grade, 'isStudent': isStudent, 'token': token.token, } form = UserCreationForm(initial=initial) return render(request, 'users/create_account.html', {'form': form}) messages.warning(request, "Invalid token") return redirect('/register/')
def create(self, validated_data): students = [Student(**item) for item in validated_data] return Student.objects.bulk_create(students)
def test_assignment_template_list_student(self): """ Tests that assignment templates are properly listed for students. """ # create a labgroup labgroup_1 = LabGroup(group_name='A', course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='ABC') labgroup_1.save() # create an unused labgroup labgroup_2 = LabGroup(group_name='B', course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='ABC') labgroup_2.save() # create student user student_user = User.objects.create_user(username='******', password=self.password) Student(user=student_user, wwuid='1111111', labgroup=labgroup_1).save() group = permissions.get_or_create_student_permissions() group.user_set.add(student_user) self.client.logout() self.client.login(username=student_user.username, password=self.password) # add assignment templates to database at1 = AssignmentTemplate(name='test name 1', course=self.course) at1.save() at2 = AssignmentTemplate(name='test name 2', course=self.course) at2.save() # assign student the first assignment template assignment = Assignment( assignment_template=at1, labgroup=labgroup_1, open_date=datetime.now(timezone(settings.TIME_ZONE)) - timedelta(days=1), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) assignment.save() # create different assignment Assignment(assignment_template=at2, labgroup=labgroup_2, open_date=datetime.now(timezone(settings.TIME_ZONE)) - timedelta(days=1), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) # request response = self.client.get(reverse(self.view_name)) response_body = json.loads(response.content.decode('utf-8')) # test response assignments = AssignmentTemplate.objects.all() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response_body['templates']), 1) self.assertEqual(response_body['templates'][0]['pk'], assignments[0].id) self.assertEqual(response_body['templates'][0]['course'], assignments[0].course.id) self.assertEqual(response_body['templates'][0]['name'], assignments[0].name)
class AssignmentEntryTest(APITestCase): """ Test cases for viewing the user's assignment entry on AssignmentEntryView. """ def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.client.login(username=self.student_username, password=self.password) # populate test database self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.course = Course(name='Bounty Hunting 101') self.course.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='4', group_name='Group A') self.group.save() self.student = Student(user=self.student_user, labgroup=self.group, wwuid='1111111') self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() self.assignment = Assignment( assignment_template=self.template, labgroup=self.group, open_date=datetime.now(timezone(settings.TIME_ZONE)), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) self.assignment.save() # retrieve the view self.view_name = 'api:assignment-entry' def test_view_assignment_entry(self): """ Tests that an assignment entry is properly retrieved. """ # create assignment entry assignment_entry = AssignmentEntry(student=self.student, assignment=self.assignment) assignment_entry.save() # request response = self.client.get( reverse(self.view_name, args=[self.assignment.id])) response_body = json.loads(response.content.decode('utf-8')) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['pk'], assignment_entry.id) self.assertEqual(response_body['student'], self.student.id) self.assertEqual(response_body['assignment'], self.assignment.id) self.assertTrue('start_date' in response_body.keys()) self.assertTrue('submit_date' in response_body.keys()) def test_view_assignment_entry_not_started(self): """ Tests that an assignment entry is not retrieved if it has not been started. """ # request response = self.client.get( reverse(self.view_name, args=[self.assignment.id])) # test response self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class AssignmentEntryEntrySubmitTest(APITestCase): """ Test cases for submitting assignment on AssignmentEntrySubmitView. """ def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.client.login(username=self.student_username, password=self.password) # populate test database self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.course = Course(name='Bounty Hunting 101') self.course.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='4', group_name='Group A') self.group.save() self.student = Student(user=self.student_user, labgroup=self.group, wwuid='1111111') self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() self.assignment = Assignment( assignment_template=self.template, labgroup=self.group, open_date=datetime.now(timezone(settings.TIME_ZONE)), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) self.assignment.save() self.assignment_entry = AssignmentEntry(student=self.student, assignment=self.assignment) self.assignment_entry.save() # retrieve the view self.view_name = 'api:assignment-entry-submit' def test_assignment_entry_submit(self): """ Tests that an assignment is properly submitted. """ # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) response_body = json.loads(response.content.decode('utf-8')) # test database assignment_entry = AssignmentEntry.objects.get( id=self.assignment_entry.id) self.assertEqual(assignment_entry.student, self.student) self.assertEqual(assignment_entry.assignment, self.assignment) self.assertNotEqual(assignment_entry.start_date, None) self.assertNotEqual(assignment_entry.submit_date, None) # test response self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_body['pk'], assignment_entry.id) self.assertEqual(response_body['student'], self.student.id) self.assertEqual(response_body['assignment'], self.assignment.id) self.assertTrue('start_date' in response_body.keys()) self.assertTrue('submit_date' in response_body.keys()) def test_assignment_entry_does_not_exist(self): """ Tests that nothing happens when the assignment does not exist. """ # request response = self.client.post(reverse(self.view_name, args=[0])) # test database assignment_entry = AssignmentEntry.objects.get( id=self.assignment_entry.id) self.assertEqual(assignment_entry.submit_date, None) # test response self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_assignment_entry_not_started(self): """ Tests that nothing happens when the assignment entry has not been started. """ # delete assignment_entry self.assignment_entry.delete() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 0) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_assignment_entry_already_submitted(self): """ Tests that nothing happens when the assignment entry has already been submitted. """ # submit assignment self.assignment_entry.submit_date = datetime.now( timezone(settings.TIME_ZONE)) self.assignment_entry.save() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test response self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # test database self.assertEqual( AssignmentEntry.objects.get( id=self.assignment_entry.id).submit_date, self.assignment_entry.submit_date) def test_assignment_closed(self): """ Tests that nothing happens when the user tries to start an assignment that has been closed. """ # modify open dates self.assignment.open_date = datetime.now(timezone( settings.TIME_ZONE)) - timedelta(days=2) self.assignment.close_date = datetime.now(timezone( settings.TIME_ZONE)) - timedelta(days=1) self.assignment.save() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test response self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # test database self.assertEqual(self.assignment_entry.submit_date, None)
def registration_submission(request): token = request.META.get('HTTP_X_MOUNTAINHACKS') if not token: print "no token" raise PermissionDenied({"message":"You don't have permission to access"}) try: tokobj = SessionToken.objects.get(val=token) tokobj.delete() except SessionToken.DoesNotExist: print "token does not exist" raise PermissionDenied({"message":"You don't have permission to access"}) post = request.POST print post first_name = post.get('first_name') last_name = post.get('last_name') major = post.get('major') email = post.get('email') school = post.get('school') grade = post.get('grade') gender = post.get('gender') shirt = post.get('shirt') out_of_state = post.get('out_of_state') github = post.get('github') linkedin = post.get('linkedin') first = post.get('first') resume = request.FILES.get('resume') if out_of_state == "Yes": out_of_state = True else: out_of_state = False if first == "Yes": first = True else: first = False student = Student(first_name=first_name, last_name=last_name, major=major, email=email, school=school, grade=grade, gender=gender, shirt_size=shirt, out_of_state=out_of_state, github_handle=github, linkedin_link=linkedin, first_hackathon=first, resume=resume, confirmation_code=TokenGenerator.get_confirmation_code()) student.save() message = "%s %s has registered for MountainHacks 2015!" % (first_name, last_name) subject = "New Registrant!" message1 = (subject, message, "*****@*****.**", ["*****@*****.**",]) message2 = ("MountainHacks 2015 Confirmation", "Thanks for registering! Please confirm this email by clicking on the following link: http://api.mountainhacks.com/api/confirm?code="+student.confirmation_code, "*****@*****.**", [email,]) send_mass_mail((message1, message2), fail_silently=False) return HttpResponse(status=201)
class AssignmentEntryStartTest(APITestCase): """ Test cases for starting assignments on AssignmentEntryStartView. """ def setUp(self): # create test user with permissions self.student_username = '******' self.instructor_username = '******' self.password = '******' self.student_user = User.objects.create_user( username=self.student_username, password=self.password) self.instructor_user = User.objects.create_user( username=self.instructor_username, password=self.password) self.client.login(username=self.student_username, password=self.password) # populate test database self.instructor = Instructor(user=self.instructor_user, wwuid='9994141') self.instructor.save() self.course = Course(name='Bounty Hunting 101') self.course.save() self.group = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='4', group_name='Group A') self.group.save() self.student = Student(user=self.student_user, labgroup=self.group, wwuid='1111111') self.student.save() self.template = AssignmentTemplate(course=self.course, name='Royalty Kidnapping Section A') self.template.save() self.assignment = Assignment( assignment_template=self.template, labgroup=self.group, open_date=datetime.now(timezone(settings.TIME_ZONE)), close_date=datetime.now(timezone(settings.TIME_ZONE)) + timedelta(days=1)) self.assignment.save() # retrieve the view self.view_name = 'api:assignment-entry-start' def test_assignment_start(self): """ Tests that an assignment entry is properly created. """ # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) response_body = json.loads(response.content.decode('utf-8')) # test return code self.assertEqual(response.status_code, status.HTTP_201_CREATED) # test database assignment_entry = AssignmentEntry.objects.get(id=response_body['pk']) self.assertEqual(assignment_entry.student, self.student) self.assertEqual(assignment_entry.assignment, self.assignment) self.assertNotEqual(assignment_entry.start_date, None) self.assertEqual(assignment_entry.submit_date, None) # test response self.assertEqual(response_body['pk'], assignment_entry.id) self.assertEqual(response_body['student'], assignment_entry.student.id) self.assertEqual( datetime.strptime(response_body['start_date'], '%Y-%m-%dT%H:%M:%S.%fZ'), assignment_entry.start_date.replace(tzinfo=None)) self.assertEqual(response_body['submit_date'], None) def test_assignment_start_duplicate(self): """ Tests that nothing happens when the assignment is started more than once. """ # create extra assignment entry self.client.post(reverse(self.view_name, args=[self.assignment.id])) # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 1) # test response self.assertEqual(response.status_code, status.HTTP_409_CONFLICT) def test_assignment_does_not_exist(self): """ Tests that nothing happens when the assignment does not exist. """ response = self.client.post(reverse(self.view_name, args=[0])) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 0) # test response self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_student_not_assigned_assignment(self): """ Tests that nothing happens when the user tries to start an assignment not assigned to their labgroup. """ # add user to different labgroup new_labgroup = LabGroup(course=self.course, instructor=self.instructor, term=get_current_term(), enroll_key='ABC', group_name='Group B') new_labgroup.save() self.student.labgroup = new_labgroup self.student.save() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 0) # test response self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_assignment_not_open(self): """ Tests that nothing happens when the user tries to start an assignment that is not open. """ # modify open dates self.assignment.open_date = datetime.now(timezone( settings.TIME_ZONE)) + timedelta(days=1) self.assignment.close_date = datetime.now(timezone( settings.TIME_ZONE)) + timedelta(days=2) self.assignment.save() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test response self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 0) def test_assignment_closed(self): """ Tests that nothing happens when the user tries to start an assignment that has been closed. """ # modify open dates self.assignment.open_date = datetime.now(timezone( settings.TIME_ZONE)) - timedelta(days=2) self.assignment.close_date = datetime.now(timezone( settings.TIME_ZONE)) - timedelta(days=1) self.assignment.save() # request response = self.client.post( reverse(self.view_name, args=[self.assignment.id])) # test response self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # test database self.assertEqual(len(AssignmentEntry.objects.all()), 0)
def import_data(request): form = ImportForm() if request.method == "POST": form = ImportForm(request.POST, request.FILES) if form.is_valid(): category = form.cleaned_data['category'] lines = process_csv_file(request, True) for line in lines: line = line.split(',') code = generate_student_code() admission_number = line[0] name = line[1].split(' ') first_name = name[0] last_name = name[1] date_of_birth = line[2] gender = line[3] school_class = line[4] stream = line[5] dormitory = line[6] religion = line[7] district = line[8] nationality = line[9] home_address = line[10] email = line[11] date_joined = line[12] class_joined = line[13] disabled = line[14] other_info = line[15] student_nin = line[16] school_id = 1 father_name = line[17] father_telephone = line[18] father_email = line[19] father_occupation = line[20] father_nin = line[21] mother_name = line[22] mother_telephone = line[23] mother_email = line[24] mother_occupation = line[25] mother_nin = line[26] if category == '1': student = Student(first_name=first_name, last_name=last_name, date_of_birth=date_of_birth, gender=gender, school_class=school_class, stream=stream, other_info=other_info, nin=student_nin, admission_number=admission_number, school_id=school_id, religion=religion, code=code) student.save() print(father_name) ''' add parents ''' if father_name: name = father_name.split(' ') user = User( email=father_email, username=father_email, is_active=False, first_name=name[0], last_name=name[1], ) user.save(commit=False) user.set_password('sw33th0m3') # user.save() father = Nok(name=father_name, student=student, occupation=father_occupation, relationship='Father', nin=father_nin, profile=Profile( user=user, type='Parent', )) father.save() if mother_name: name = mother_name.split(' ') user = User( email=mother_email, username=mother_email, is_active=False, first_name=name[0], last_name=name[1], ) user.save(commit=False) user.set_password('sw33th0m3') # user.save() mother = Nok(name=mother_name, student=student, occupation=mother_occupation, relationship='Mother', nin=mother_nin, profile=Profile( user=user, type='Parent', )) mother.save() return HttpResponseRedirect(reverse('thanks')) return render(request, 'admin/import.html', {'model': { 'form': form, 'action': 'import-data' }})