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