def _add_object_to_db(self, name):
if name == 'student':
student = Student(
first_name=self._random_value('first_name'),
last_name=self._random_value('last_name'),
ticket=self._random_value(),
birthday=timezone.now(),
)
student.save()
if name == 'group':
group = Group(
title=self._random_value('title'),
notes='note about group',
)
group.save()
if name == 'user':
user = User(
username=self._random_value('username'),
first_name=self._random_value('first_name'),
last_name=self._random_value('last_name'),
email=self._random_value("email") + '@example.com',
)
# User model have an unique field 'username'.
# Generated 'username' can be not unique
# in compare with existing objects.
# In case of exception repeat creating object 'user'.
try:
user.save()
except:
self._add_object_to_db(name)
def setUp(self):
self.c = Client()
# Create the test badge.
self.b = Badge( name = "The Super Badge",
shortname = "superbadge",
description = "This badge is quite super.",
graphic = "superbadge" )
self.b.save()
# Create some test users.
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.u2 = User.objects.create_user("alexis",
"*****@*****.**",
"alexisrulz")
self.s1 = Student( user=self.u1 )
self.s2 = Student( user=self.u2 )
self.s1.save()
self.s2.save()
# Award the badge to s1
self.b.awarded_to.add( self.s2 )
self.b.save()
# Give the test users memorable names.
self.ishara = self.s1
self.alexis = self.s2
def save(self):
""" Save an user like teacher or student"""
data = self.cleaned_data
data.pop('password_confirmation')
is_teacher = data['is_teacher']
data.pop('is_teacher')
# Crear el username
data['username'] = data['first_name'][:1] + data['last_name'].split(
' ')[0]
data['username'] = data['username'].upper()
while User.objects.filter(username=data['username']).exists():
data['username'] = data['username'] + str(randrange(1000, 9999))
user = User.objects.create_user(**data)
if is_teacher:
teacher = Teacher(user=user)
teacher.save()
else:
student = Student(user=user)
student.save()
def _add_object_to_db(self, name):
if name == 'student':
student = Student(
first_name=self._random_value('first_name'),
last_name=self._random_value('last_name'),
ticket=self._random_value(),
birthday=timezone.now(),
)
student.save()
if name == 'group':
group = Group(
title=self._random_value('title'),
notes='note about group',
)
group.save()
if name == 'user':
user = User(
username=self._random_value('username'),
first_name=self._random_value('first_name'),
last_name=self._random_value('last_name'),
email=self._random_value("email") + '@example.com',
)
# User model have an unique field 'username'.
# Generated 'username' can be not unique
# in compare with existing objects.
# In case of exception repeat creating object 'user'.
try:
user.save()
except:
self._add_object_to_db(name)
def _save_student(cl_data, data):
"""
Obtiene los datos del formulario, crea un nuevo objeto estudiante y
lo salva en la BD.
"""
#TODO: Las carreras de los estudiantes
CI = int(cl_data['ci'])
first_name = cl_data['nombre']
last_name = cl_data['pApellido'] + ' ' + cl_data['sApellido']
address = f"{cl_data['calle']} {cl_data['num']} {cl_data['apto']} {cl_data['esc']}"
address += f"{cl_data['entre']} {cl_data['y']} {cl_data['repa']} {cl_data['poblado']}"
city = cl_data['prov']
email = cl_data['email']
sex = data.sex[int(cl_data['colorSexo']) - 1][1][0]
tel = cl_data['tel']
color = int(cl_data['colorRadio'])
town = cl_data['mun']
procedence = int(cl_data['procedencia'])
ocupation = int(cl_data['ocupacionRadio'])
workSec = int(cl_data['sectorRadio'])
vinculation = True if int(cl_data['vinculaRadio']) == 1 else False
args = locals()
args.pop('cl_data')
args.pop('data')
s = Student(**args)
s.save()
def registerConStudent(request):
name = request.POST['name']
major = request.POST['major']
age = request.POST['age']
grade = request.POST['grade']
gender = request.POST['gender']
qs = Student(s_name=name, s_major=major, s_age=age, \
s_grade=grade, s_gender=gender)
qs.save()
return HttpResponseRedirect(reverse('students:listAll'))
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara", "*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student(user=self.u1)
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
def test_create_new_student(self):
new_student = Student(name='New Student',
dob=datetime.today(),
civil_id='1234567890',
mobile_number=generate_random_numbers(12),
home_number=generate_random_numbers(12),
parent_number=generate_random_numbers(12))
new_student.save()
self.assertIsInstance(new_student, Student)
self.assertTrue(new_student.pk)
self.assertEquals('P', new_student.status)
def test_log_result_exam_change_students(self):
res_exam = Result_exam(valuetion=5)
res_exam.save()
student = Student(first_name='Ioan', last_name='Serok')
student.save()
res_exam.students.add(student)
res_exam.save()
self.out.seek(0)
self.assertEqual(self.out.readlines()[-2].strip(), "List of students was modified \
in result_exam {}".format(res_exam.id))
def student_signup(request):
email = None
if request.user.is_authenticated:
email = request.user.email
student = Student.objects.filter(email_address=email)
# if len(student) > 0:
# messages.info(request, 'You have already signed up.')
# return redirect('/profile/')
if request.method == 'POST':
form = EditStudentSignupForm(request.POST)
if form.is_valid():
s = Student(
email_address=email,
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
student_id=form.cleaned_data['student_id'],
college=form.cleaned_data['college'],
major=form.cleaned_data['major'],
year=form.cleaned_data['year'],
resume_link=form.cleaned_data['resume_link'],
general_question=form.cleaned_data['general_question'],
additional_skills=form.cleaned_data['additional_skills'])
skills = s.skills
for skill in skills:
skills[skill] = form.cleaned_data.get(skill, "")
s._skills = skills
s.save()
return redirect('/profile/')
else:
logger.error(
f"Invalid profile form for student {student}:\n{form}")
messages.info(
request,
'Your application was invalid and could not be processed. If this error persists, '
'please contact [email protected].')
return redirect('/profile/')
else:
form = EditStudentSignupForm()
return render(request, 'profile/edit_student_profile.html', {
'title': "Student Create profile/",
'form': form
})
def handle(self, *args, **options):
student_names = [
'Matthew', 'Aloysius', 'Scott', 'Josh', 'Richard', 'Daniel', 'Tod',
'Joseph', 'Josephine', 'Johan', 'Joe'
]
lab_names = [
'Guess the Number', 'Mad Lab', 'Turtle', 'Contact List', 'Clock',
'Calculator'
]
section_names = ['Python', 'HTML+CSS', 'JavaScript', 'Django']
# PURGE DATA
StudentLab.objects.all().delete()
Student.objects.all().delete()
Lab.objects.all().delete()
LabSection.objects.all().delete()
for student_name in student_names:
if User.objects.filter(username=student_name).exists():
User.objects.get(username=student_name).delete()
for i, section_name in enumerate(section_names):
lab_section = LabSection(name=section_name, index=(i + 1))
lab_section.save()
for j in range(3):
lab_name = random.choice(lab_names)
lab = Lab(name=lab_name, section=lab_section, index=(j + 1))
lab.save()
lab_sections = LabSection.objects.all()
for student_name in student_names:
print('creating ' + student_name)
user = User.objects.create_user(student_name,
student_name + '@pdxcodeguild.com',
'abc123')
group = Group.objects.get(name='students')
user.groups.add(group)
user.save()
student = Student(name=student_name, user=user)
student.save()
for lab_section in lab_sections:
for lab in lab_section.lab_set.all():
if random.randint(1, 10) == 1:
continue
student_lab = StudentLab(
student=student,
lab=lab,
grade=random.choice([True, True, True, True, False]))
student_lab.save()
def student_list(request):
if request.method == 'GET':
students = Student.objects.all()
students = [{'name': s.name, 'id': s.id} for s in students]
return JsonResponse(students, safe=False)
if request.method == 'POST':
name = request.POST.get('name')
student = Student(name=name)
student.save()
context = {'code': 200, 'msg': 'post success!'}
return JsonResponse(context)
def getUser(self, type, request):
body = json.loads(request.body)
email = body['email']
password = body['password']
rcs = body['rcs']
password = hashlib.sha224(str.encode(password)).hexdigest()
type = body['type']
if type == 'STUDENT':
return Student(email=email, password=password, rcs=rcs, type=type)
# Future account types i.e. professor, admin, etc. can be implemented.
else:
return Student(email=email, password=password, rcs=rcs, type=type)
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara", "*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student(user=self.u1, twitter="isharacomix")
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
self.G = Game(title="Foo", code="")
self.G.save()
self.G.authors.add(self.ishara)
def create_demo_user(request):
me = Student.from_request(request)
if not settings.DEMO_MODE:
request.session["alerts"].append(("alert-error","Demo users are not enabled at this time."))
return redirect("index")
username = "******"%len(Student.objects.all())
user = User.objects.create_user(username, username+"@example.com", str(random.randint(100000000,999999999)))
user.save()
student = Student(user=user)
student.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
return redirect("index")
def regConStudent(request):
name = request.POST['name']
major = request.POST['major']
age = request.POST['age']
grade = request.POST['grade']
gender = request.POST['gender']
qs = Student(studentName=name,
studentMajor=major,
studentAge=age,
studentGrade=grade,
studentGender=gender)
qs.save()
return HttpResponseRedirect(reverse('students:stuAll'))
def test_log_monthjournal_delete(self): student = Student(first_name='Kick', last_name='Resl') student.save() monthjournal = MonthJournal(student=student, date=date(2016, 5, 2)) monthjournal.save() # import copy # mj = copy.deepcopy(monthjournal) mj = monthjournal monthjournal.delete() self.out.seek(0) self.assertEqual(self.out.readlines()[-1].strip(), "MonthJournal deleted: %s" % mj)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
exam_rooms = ExamRoom.objects.filter(available=True)
context['student_count'] = Student.get_current(want_exam=True).order_by('name', 'prename').count()
context['free_places_1'] = sum([exam_room.capacity(1) for exam_room in exam_rooms])
context['free_places_2'] = sum([exam_room.capacity(2) for exam_room in exam_rooms])
return context
def user_profile(request, username):
me = Student.from_request(request)
if "alerts" not in request.session: request.session["alerts"] = []
if not me:
request.session["alerts"].append(("alert-error","Please sign in first."))
return redirect("sign-in")
try: student = Student.objects.get( user=User.objects.get(username=username) )
except: return redirect("user_list")
# If we are doing a POST, then let's affect the output a bit.
form = ProfileEditForm( {"bio": me.bio, "twitter": me.twitter, "email": me.public_email} )
if request.method == "POST":
form = ProfileEditForm(request.POST)
if form.is_valid():
data = form.cleaned_data
me.bio = data["bio"]
me.public_email = data["email"]
me.twitter = data["twitter"]
me.save()
return redirect( "profile", username=me.username )
else:
request.session["alerts"].append(("alert-error",
"There were some issues with your profile update."))
for e in form.non_field_errors():
alerts.append( ("alert-error", e ) )
# Render the magic.
projects = list(me.owns.all())+list(me.works_on.all())
return render(request, "user_profile.html", {"student": student,
"collaborators": student.collaborators(),
"projects": projects,
"form": form,
'alerts': request.session.pop('alerts', []) } )
def list_badges(request):
badge_list = Badge.objects.all()
for b in badge_list:
try: b.check = True if b.held_by( Student.from_request(request) ) else False
except exceptions.ObjectDoesNotExist: b.check = False
return render( request, "badge_list.html", {"badge_list":badge_list} )
def view_feedback(request, name):
me = Student.from_request(request)
# First, try to get the challenge.
try: challenge = Challenge.objects.get(slug=name)
except exceptions.ObjectDoesNotExist: raise Http404()
# Now get all of the SOSses related to this user and challenge.
feedback = SOS.objects.filter(challenge=challenge, student=me)
# Mark feedback as helpful or not.
if "helpful" in request.GET or "unhelpful" in request.GET:
helpful = True
if "unhelpful" in request.GET: helpful = False
f_id = request.GET["helpful" if helpful else "unhelpful"]
if f_id.isdigit():
try:
f = Feedback.objects.get(id=int(f_id))
if f.sos in feedback and f.helpful is None:
f.helpful = helpful
f.save()
LogEntry.log(request, "Marked as %shelpful"%("" if helpful else "un"))
except exceptions.ObjectDoesNotExist:
LogEntry.log(request, "Feedback voting naughtiness.")
return render(request, "feedback.html", {'challenge': challenge,
'feedback': feedback})
def handle(self, *args, **options):
Group.objects.all().delete()
Student.objects.all().delete()
Teacher.objects.all().delete()
# Create 100 students wo group/teacher
students = [Student.generate_student() for i in range(100)]
print(len(students))
# Create 10 teachers wo group
teachers = [Teacher.gen_teacher() for i in range(10)]
print(len(teachers))
# Create 10 groups wo teacher and senior
groups = [Group.gen_group() for i in range(10)]
# Update students with random Group
for student in students:
student.groups = random.choice(groups)
print(student.groups)
student.save()
# Add for Group senior FROM THE GROUP and curator - random teacher
for group in groups:
while group.senior is None:
student = random.choice(students)
if student.groups.id == group.id:
group.senior = student
else:
print(f'student {student.groups} not in group {group.id}')
group.curator = random.choice(teachers)
group.save()
print(group.get_info())
def test_log_monthjournal_add_update(self): student = Student(first_name='Nick', last_name='Rest') student.save() monthjournal = MonthJournal(student=student, date=date(2016, 5, 2)) monthjournal.save() self.out.seek(0) self.assertEqual(self.out.readlines()[-1].strip(), "MonthJournal created: %s" % monthjournal) monthjournal.present_day1 = True monthjournal.save() self.out.seek(0) self.assertEqual(self.out.readlines()[-1].strip(), "MonthJournal updated: %s" % monthjournal)
def test_log_group_add_update_event(self):
student = Student(first_name='Demo', last_name='Student')
student.save()
group = Group(title='TTE')
group.save()
self.out.seek(0)
self.assertEqual(self.out.readlines()[-1], "Group added: %s (ID: %d)\n" % (group.title, group.id))
group.leader = student
group.save()
self.out.seek(0)
self.assertEqual(self.out.readlines()[-1].strip(), "Group edited: {} (ID: {})".format(group.title, group.id))
def test_str(self):
group = Group(title='Some Title')
self.assertEqual(str(group), 'Some Title')
student = Student(id=1, first_name='Test', last_name='Student')
group2 = Group(title='Another Title', leader=student)
self.assertEqual(str(group2), 'Another Title (Test Student)')
def view_feedback(request, name):
me = Student.from_request(request)
if "alerts" not in request.session: request.session["alerts"] = []
if not me:
request.session["alerts"].append(("alert-error","Please sign in first."))
return redirect("sign-in")
# First, try to get the challenge.
try: challenge = Challenge.objects.get(slug=name)
except exceptions.ObjectDoesNotExist: raise Http404()
# Now get all of the SOSses related to this user and challenge.
feedback = SOS.objects.filter(challenge=challenge, student=me)
# Mark feedback as helpful or not.
if "helpful" in request.GET or "unhelpful" in request.GET:
helpful = True
if "unhelpful" in request.GET: helpful = False
f_id = request.GET["helpful" if helpful else "unhelpful"]
if f_id.isdigit():
f = Feedback.objects.get(id=int(f_id))
if f.sos in feedback and f.helpful is None:
f.helpful = helpful
f.save()
if helpful:
f.author.award_xp(50)
me.award_xp(5)
LogEntry.log(request, "Marked as %shelpful"%("" if helpful else "un"))
return render(request, "feedback.html", {'challenge': challenge,
'feedback': feedback})
def register_student_add(request):
if request.method=="POST":
first_name=request.POST['first_name']
last_name=request.POST['last_name']
gender=request.POST['gender']
username=request.POST['username']
password=request.POST['password']
class_id=request.POST['class_id']
# hash the password
hashed_password = sha256_crypt.encrypt(password)
student=Student(first_name=first_name,last_name=last_name,gender=gender,username=username,password=hashed_password,classid_id=class_id)
student.save()
return login_student_form(request)
def regConStudent(request):
name = request.POST['name']
major = request.POST['major']
age = request.POST['age']
grade = request.POST['grade']
gender = request.POST['gender']
# 데이터베이스에 request로부터 전달받은 데이터를 테이블에 저장하는 쿼리
qs = Student(s_name=name,
s_major=major,
s_age=age,
s_grade=grade,
s_gender=gender)
qs.save()
# 마지막으로 웹페이지사용자에게 "학생전체보기 페이지" url인 students/all 에 연결시켜준다.
return HttpResponseRedirect(reverse('students:stuAll'))
def __init__(self, number=1):
Student.objects.bulk_create([
Student(first_name=f'Student #{_}',
last_name='-',
email=f'student_{_}@mail.com') for _ in range(number)
])
self.students = Student.objects.all()
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student( user=self.u1 )
self.s1.save()
p = Page(name="index", content="Hello world")
p.save()
p = Page(name="test", content="This is a test.")
p.save()
# Give the test users memorable names.
self.ishara = self.s1
def setUp(self):
self.student = Student(first_name="Demo", last_name="Student")
self.group = Group(title="Demo Group")
self.time_now = datetime.now()
self.exam = Exam(name="Math",
date=self.time_now,
teacher_name="Visiliy Ivanov",
exam_group=self.group)
def view_board(request, category):
me = Student.from_request(request)
# First, try to get the board.
try: board = DiscussionBoard.objects.get(slug=category)
except exceptions.ObjectDoesNotExist: raise Http404()
if not board.can_read(me): raise Http404()
# Get the page number!
page = 0
pagination = 50
if "page" in request.GET and request.GET["page"].isdigit():
page = max(0,int(request.GET["page"])-1)
# If this is a POST, we are creating a new topic. Redirect when finished.
if request.method == "POST":
if board.can_write(me):
content = str(request.POST.get("content"))
title = content[:100]+"..."
if "title" in request.POST:
title = request.POST["title"]
t = DiscussionTopic()
t.author = me
t.board = board
t.title = title
t.save()
p = DiscussionPost()
p.topic = t
p.author = me
p.content = content
p.save()
return redirect( "thread", category=board.slug, thread=t.id )
else:
return redirect( "board", category=board.slug )
# Get all of the topics, along with the last person who commented on them
# and when that was.
topic_tuples = []
topics = DiscussionTopic.objects.filter(board=board)
if not me.ta:
topics = topics.filter(hidden=False)
for t in topics[pagination*page:pagination*(page+1)]:
posts = DiscussionPost.objects.filter(topic=t, hidden=False).order_by("-timestamp")
count = len(posts)
new = False
if count == 0: posts = [None]
else: new = ( posts[0].timestamp > me.unread_since )
topic_tuples.append( (t,count,posts[0],new) )
return render( request, "forum_topics.html", {'board': board,
'topics': topic_tuples,
'alerts': request.session.pop('alerts', []),
'page': page+1,
'pages': (len(topic_tuples)/pagination)+1,
'can_write': board.can_write(me) } )
def min_user(min_user_data):
""" A student account that fulfills minimum requirements """
student = Student(**min_user_data)
student.set_password(min_user_data['password'])
student.is_confirmed = True
student.save()
return student
def max_user(max_user_data):
""" A student account that fills all fields """
student = Student(**max_user_data)
student.set_password(max_user_data['password'])
student.is_confirmed = True
student.save()
return student
def test_log_student_updated_added_event(self):
''' Check logging signal for newly created student '''
# add own root handler to catch student signals output
out = StringIO()
handler = logging.StreamHandler(out)
logging.root.addHandler(handler)
# now create student, this should raise new message inside
# our logger output file
student = Student(first_name='Demo', last_name='Student')
student.save()
# check output file content
out.seek(0)
self.assertEqual(out.readlines()[-1],
'Student added: Demo Student (ID: %d)\n' % student.id)
# now update existing student and check last line in out
student.ticket = '12345'
student.save()
out.seek(0)
self.assertEqual(
out.readlines()[-1],
'Student updated: Demo Student (ID: %d)\n' % student.id)
# remove our handler from root logger
logging.root.removeHandler(handler)
def test_link_course(self):
course = Course.objects.create(
name='Django Base',
short_description='Django Base Course')
course.save()
student = Student(
name="Ivan",
surname="Ivanov",
date_of_birth="1999-09-09",
email="*****@*****.**",
phone="1234567890",
address="Mykolyiv",
skype="test")
student.save()
student.courses.add(course)
response = self.client.get('/students/1/')
self.assertContains(response, '/courses/{}/'.format(student.id))
self.assertContains(response, 'Django Base')
def student_add(request):
if request.method == 'POST':
form = StudentForm(request.POST)
if form.is_valid():
print form.cleaned_data
student = Student(
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'],
phone_number=form.cleaned_data['phone_number'],
package=form.cleaned_data['package'],
# courses=form.cleaned_data['courses'], ???????????????????
)
student.save()
return redirect('students_list')
else:
form = StudentForm()
return render(request, 'student_edit.html', {'form': form, 'title': 'Add student'})
def view_board(request, name):
me = Student.from_request(request)
if "alerts" not in request.session: request.session["alerts"] = []
if not me:
request.session["alerts"].append(("alert-error","Please sign in first."))
return redirect("sign-in")
# First, try to get the board.
try: board = DiscussionBoard.objects.get(slug=name)
except exceptions.ObjectDoesNotExist: raise Http404()
if board.restricted > me.level: raise Http404()
# Get the page number!
page = 0
pagination = 200
if "page" in request.GET and request.GET["page"].isdigit():
page = max(0,int(request.GET["page"])-1)
# If this is a POST, we are creating a new topic. Redirect when finished.
if request.method == "POST" and (me.level >= board.wrestricted or me.ta):
content = str(request.POST.get("content"))
title = content[:100]+"..."
if "title" in request.POST:
title = request.POST["title"]
t = DiscussionTopic()
t.author = me
t.board = board
t.title = title
t.save()
p = DiscussionPost()
p.topic = t
p.author = me
p.content = content
p.save()
return redirect( "thread", name=board.slug, thread=t.id )
# Get all of the topics, along with the last person who commented on them
# and when that was.
topic_tuples = []
for t in DiscussionTopic.objects.filter(hidden=False, board=board)[pagination*page:pagination*(page+1)]:
posts = DiscussionPost.objects.filter(topic=t, hidden=False).order_by("-timestamp")
count = len(posts)
new = False
if count == 0: posts = [None]
else: new = ( posts[0].timestamp > me.last_login )
topic_tuples.append( (t,count,posts[0],new) )
return render( request, "forum_topics.html", {'board': board,
'topics': topic_tuples,
'student': me,
'alerts': request.session.pop('alerts', []),
'page': page+1,
'pages': (len(topic_tuples)/pagination)+1 } )
def students(request):
if request.method == "POST":
sid = request.POST["sid"]
firstname = request.POST["firstname"]
lastname = request.POST["lastname"]
department = request.POST["department"]
section = request.POST["section"]
year = request.POST["year"]
student = Student(student_id=sid,
firstname=firstname,
lastname=lastname,
department=department,
section=section,
year=year)
student.save()
return redirect("students")
students = Student.objects.all()
return render(request, "students.html", {"students": students})
def handle(self, **options):
randusersreq = requests.get(
"https://randomuser.me/api/?results=100&nat=NL")
randusersjson = json.loads(randusersreq.text)
randusers = randusersjson['results']
randusernames = map(
lambda x: x["name"]["first"].capitalize() + " " + x["name"]["last"]
.capitalize(), randusers)
for user in randusernames:
st = Student(name=user,
AK_points=random.randint(0, 20),
IT_points=random.randint(0, 20),
KU_points=random.randint(0, 20),
NL_points=random.randint(0, 20),
RE_points=random.randint(0, 20),
EN_points=random.randint(0, 20),
GE_points=random.randint(0, 20),
MA_points=random.randint(0, 20))
st.save()
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.s1 = Student( user=self.u1 )
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
def test_log_student_deleted_event(self):
"""Check logging signals for deleted student"""
student = Student(first_name='Demo', last_name='Student')
student.save()
# now override signal
# add own root handler to catch student signals output
out = StringIO()
handler = logging.StreamHandler(out)
logging.root.addHandler(handler)
# delete existing student and check logger output
sid = student.id
student.delete()
out.seek(0)
self.assertEqual(out.readlines()[-1], 'Student Demo Student deleted (ID: %d)\n' % sid)
# remove our handler from root logger
logging.root.removeHandler(handler)
def handle_login(request):
me = Student.from_request(request)
if me:
request.session["alerts"].append(("alert-error","You are already logged in!"))
return redirect("index")
request.session["secret_state"] = str(random.randint(100000000,999999999))
return redirect("https://github.com/login/oauth/authorize?client_id=%s&state=%s&scope=user:email"%
(settings.GITHUB_ID, request.session["secret_state"]))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
exam_rooms = ExamRoom.objects.filter(available=True)
context['student_count'] = Student.get_current(
want_exam=True).order_by('name', 'prename').count()
context['free_places_1'] = sum(
[exam_room.capacity(1) for exam_room in exam_rooms])
context['free_places_2'] = sum(
[exam_room.capacity(2) for exam_room in exam_rooms])
return context
def setUp(self):
# add our root handler
self.out = StringIO()
self.handler = logging.StreamHandler(self.out)
logging.root.addHandler(self.handler)
self.time_now = datetime.now()
self.group = Group(title='DemoGroup')
self.student = Student(first_name='Demo',
last_name="Student",
ticket='1',
birthday='1980-01-01',
student_group=self.group)
self.exam = Exam(name="Math",
date=self.time_now,
teacher_name="Visiliy Ivanov",
exam_group=self.group)
self.result = Result(result_student=self.student,
result_exam=self.exam,
score=10)
def view_thread(request, name, thread):
me = Student.from_request(request)
if "alerts" not in request.session: request.session["alerts"] = []
if not me:
request.session["alerts"].append(("alert-error","Please sign in first."))
return redirect("sign-in")
# First, try to get the challenge, then thread.
try:
board = DiscussionBoard.objects.get(slug=name)
topic = DiscussionTopic.objects.get(id=thread, board=board)
except exceptions.ObjectDoesNotExist: raise Http404()
if not me.ta and (topic.hidden or board.restricted > me.level): raise Http404()
# If this is a POST, we are either replying to someone or we are voting.
# Manage permissions respectively and redirect.
if request.method == "POST":
if "thread" in request.POST and (me.level >= board.wrestricted or me.ta):
p = DiscussionPost()
p.topic = topic
p.author = me
p.content = str(request.POST.get("content"))
p.save()
topic.save()
elif "upvote" in request.POST or "downvote" in request.POST:
upvote = True
if "downvote" in request.POST: upvote = False
p_id = request.POST["upvote" if upvote else "downvote"]
if p_id.isdigit() and (me.modpoints > 0 or me.ta):
p = DiscussionPost.objects.get(id=int(p_id))
if upvote: p.upvotes += 1
else: p.downvotes += 1
request.session["alerts"].append(("alert-success","Post %s."%("upvoted" if upvote else "downvoted")))
LogEntry.log(request, "Thread %s"%("upvoted" if upvote else "downvoted"))
p.save()
me.modpoints -= 1
me.award_xp(1)
me.save()
return redirect( "thread", name=board.slug, thread=topic.id )
# Get all of the posts. Start on the last page by default.
pagination = 20
posts = DiscussionPost.objects.filter(hidden=False, topic=topic)
pages = (len(posts)/pagination)+1
page = pages-1
if "page" in request.GET and request.GET["page"].isdigit():
page = max(0,int(request.GET["page"])-1)
return render( request, "forum_thread.html", {'board': board,
'topic': topic,
'student': me,
'posts': posts[pagination*page:pagination*(page+1)],
'alerts': request.session.pop('alerts', []),
'page': page+1,
'pages': pages })
def handle_logout(request):
me = Student.from_request(request)
if me:
logout(request)
if "alerts" not in request.session: request.session["alerts"] = []
request.session["alerts"].append(("alert-success","Successfully logged out - come back soon!"))
return redirect("index")
else:
request.session["alerts"].append(("alert-error","You're already logged out!"))
return redirect("index")
def view_stage(request, world, stage):
try: student = Student.from_request(request)
except exceptions.ObjectDoesNotExist: return HttpResponse("Redirect to login")
here = get_stage(world, stage)
go = "lesson"
# if in challenge-first group: go = "challenge"
# If there is only one choice, then go to that one.
if not here.lesson and here.challenge: go = "challenge"
if not here.challenge and here.lesson: go = "lesson"
return redirect( go, world = world, stage = stage )
def view_lesson(request, world, stage):
try: student = Student.from_request(request)
except exceptions.ObjectDoesNotExist: return HttpResponse("Redirect to login")
here = get_stage(world, stage)
if not here.lesson:
if here.challenge: return redirect( "challenge", world = world, stage = stage )
else: raise Http404()
#TODO log this as read.
return render( request, "lessons_lesson.html", {'world': here.world,
'stage': here } )
def test_log_student_deleted_event(self):
"""Check logging signal for deleted student"""
# add own root handler to catch student signals output
out = StringIO()
handler = logging.StreamHandler(out)
logging.root.addHandler(handler)
# now create and delete student, this should raise new message inside
# our logger output file
student = Student(first_name='Demo', last_name='Student', ticket='123')
student.save()
student_id = student.id
student.delete()
# check output file content
out.seek(0)
self.assertEqual(out.readlines()[-1],
'Student deleted: Demo Student (ID: %d)\n' % student_id)
# remove our handler from root logger
logging.root.removeHandler(handler)
class StudentTests(TestCase):
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.s1 = Student( user=self.u1 )
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
# Test User Connection decorators.
def test_user_fields(self):
self.assertEquals(self.s1.username, self.u1.username)
self.assertEquals(self.s1.email, self.u1.email)
# Test the Profile page.
def test_profile_page(self):
response = self.c.get("/~ishara")
self.assertEqual(response.status_code, 200)
def test_log_student_updated_added_event(self):
"""Check logging signal for newly created dtudent"""
# add own root handler to catch student signals output
out = StringIO()
handler = logging.StreamHandler(out)
logging.root.addHandler(handler)
# now create student, this should raise new message inside our logger output file
student = Student(first_name='Demo', last_name='Student')
student.save()
# check output file content
out.seek(0)
self.assertEqual(out.readlines()[-1],
'Student added: Demo Student (ID: %d)\n' % student.id)
# now update existing student and check last line in out
student.ticket = '12345'
student.save()
out.seek(0)
self.assertEqual(out.readlines()[-1],
'Student updated: Demo Student (ID: %d)\n' % student.id)
# remove our handler from root logger
logging.root.removeHandler(handler)
def view_thread(request, category, thread):
me = Student.from_request(request)
# First, try to get the challenge, then thread.
try:
board = DiscussionBoard.objects.get(slug=category)
topic = DiscussionTopic.objects.get(id=thread, board=board)
except exceptions.ObjectDoesNotExist: raise Http404()
if not board.can_read(me): raise Http404()
# If this is a POST, we are either replying to someone or we are voting.
# Manage permissions respectively and redirect.
if request.method == "POST":
if "hide" in request.POST and me.ta:
try:
p = DiscussionPost.objects.get(id=int(request.POST["hide"]))
p.hidden = not p.hidden
p.save()
except: pass
elif "topic" in request.POST and me.ta:
if "lock" == request.POST.get("topic"):
topic.locked = not topic.locked
if "hide" == request.POST.get("topic"):
topic.hidden = not topic.hidden
topic.save()
elif "content" in request.POST and board.can_write(me) and (not topic.locked):
p = DiscussionPost()
p.topic = topic
p.author = me
p.content = str(request.POST.get("content"))
p.save()
topic.save()
return redirect( "thread", category=board.slug, thread=topic.id )
# Get all of the posts. Start on the last page by default.
pagination = 20
posts = DiscussionPost.objects.filter(topic=topic)
if not me.ta:
post = posts.filter(hidden=False)
pages = (len(posts)/pagination)+1
page = pages-1
if "page" in request.GET and request.GET["page"].isdigit():
page = max(0,int(request.GET["page"])-1)
return render( request, "forum_thread.html", {'board': board,
'topic': topic,
'posts': posts[pagination*page:pagination*(page+1)],
'alerts': request.session.pop('alerts', []),
'page': page+1,
'pages': pages,
'can_write': board.can_write(me) })
def sign_out(request):
me = Student.from_request(request)
if "alerts" not in request.session: request.session["alerts"] = []
if me:
logout(request)
if "alerts" not in request.session: request.session["alerts"] = []
request.session["alerts"].append( ("alert-success",
"You have successfully signed out.") )
return redirect("index")
else:
request.session["alerts"].append( ("alert-success",
"You are already signed out.") )
return redirect("sign-in")
def setUp(self):
self.o1 = Ophase.objects.create(name="Testophase 1", is_active=True)
self.gc = OphaseCategory.objects.create(name="Super Mario", priority=10)
self.assertEqual(self.gc.name, "Super Mario")
self.tg = TutorGroup.objects.create(
ophase=self.o1, name="Mario", group_category=self.gc)
self.assertEqual(self.tg.name, "Mario")
self.st = Student(prename="John", name="Doe", email="*****@*****.**",
tutor_group=self.tg, want_exam=True)
self.n1 = Newsletter(name='Test Newsletter',
description='This newsletter is only for test')
class TestMooc(TestCase):
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student( user=self.u1 )
self.s1.save()
p = Page(name="index", content="Hello world")
p.save()
p = Page(name="test", content="This is a test.")
p.save()
# Give the test users memorable names.
self.ishara = self.s1
# Try to go to the home page.
def test_home_page(self):
response = self.c.get("/")
self.assertEqual(response.status_code, 200)
self.assertTrue("/sign-up/" in response.content)
# Log in and go to the home page.
def test_logged_in_dash(self):
self.c.login(username="******", password="******")
response = self.c.get("/")
self.assertEqual(response.status_code, 200)
self.assertTrue("/sign-out/" in response.content)
# Make sure searching works.
def test_search(self):
response = self.c.get("/search/?query=world", follow=True)
self.assertTrue( "/help/index/" in response.content )
class TestNESViews(TestCase):
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student( user=self.u1, twitter="isharacomix" )
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
self.G = Game(title="Foo", code="")
self.G.save()
self.G.authors.add(self.ishara)
#
def test_arcade(self):
response = self.c.get("/arcade/1/")
self.assertEqual(response.status_code, 200)
self.assertTrue("http://twitter.com/isharacomix" in response.content)
response = self.c.get("/arcade/1/?download", follow=True)
self.assertEqual(response.status_code, 200)
def setUp(self):
self.c = Client()
self.u1 = User.objects.create_user("ishara",
"*****@*****.**",
"ishararulz")
self.u1.save()
self.s1 = Student( user=self.u1, twitter="isharacomix" )
self.s1.save()
# Give the test users memorable names.
self.ishara = self.s1
self.G = Game(title="Foo", code="")
self.G.save()
self.G.authors.add(self.ishara)
