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 register(self, request):
# Check for username exists
serializer = RegisterSerializer(data=request.data)
if serializer.is_valid():
username = serializer.data.get('username')
email = serializer.data.get('email')
password = serializer.data.get('password')
first_name = serializer.data.get('first_name')
last_name = serializer.data.get('last_name')
else:
return Response({'detail': "Invalid Form Data"}, status=400)
if username in Student.objects.all().values_list(
'username') or email in User.objects.all().values_list(
'email'):
return Response(
{'detail': "User with that username already exists"},
status=400)
user = Student()
user.username = username
user.email = email
user.set_password(password)
user.first_name = first_name
user.last_name = last_name
user.is_active = False
user.save()
return Response(
{
'detail':
"Registered Successfully, please contact Admin for Approval"
},
status=201)
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 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 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 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 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 _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.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 __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()
# Give the test users memorable names.
self.ishara = self.s1
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 import_student_from_csv(csv_file, lecturer):
"""
Import student CSV data.
"""
csv_data = []
ifile = csv_file.read().decode("utf-8")
for row in ifile.split('\n'):
csv_data.append(row.split(','))
result_objects = []
# Check if headers exists. Skip the first entry if true.
header_check = [
'reg_number', 'surname', 'first_name', 'sex', 'level', 'department',
'year_of_admission', 'course_duration'
]
first_row = [i.lower().strip() for i in csv_data[0]]
# if all(i in first_row for i in header_check):
csv_data = csv_data[1:]
new_value = 0
existing_value = 0 # To get the number of records entered
for row in csv_data:
# Let's do an extra check to make sure the row is not empty.
if row:
department = Department.objects.get(code=str(row[5]).upper())
if Student.objects.filter(reg_number=row[0]).exists():
existing_value += 1
else:
user = create_user(row[1], row[2])
user.username = row[0]
user.password = row[0]
user.save()
student = Student(
reg_number=row[0],
user=user,
last_name=row[1],
first_name=row[2],
department=department,
institution=lecturer.institution,
year_of_admission=row[6],
level=row[4],
course_duration=row[7],
sex=row[3],
)
setup = StudentSetup(user=user)
setup.save()
activation = Activation(user=user)
activation.save()
create_slug(student)
new_value += 1
return new_value, existing_value
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 handle(self, *args, **options):
fake = Faker()
students = []
for _ in range(1000):
students.append(
Student(
first_name=fake.first_name(),
last_name=fake.last_name(),
age=random.randint(20, 40),
))
Student.objects.bulk_create(students)
def save(self):
student = Student(
email = self.validated_data['email'],
name = self.validated_data['name'],
lastname = self.validated_data['lastname'],
carne = self.validated_data['carne'],
sship = self.validated_data['sship']
)
password = self.validated_data['password']
student.set_password(password)
student.save()
return student
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 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_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 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 handle(self, *args, **kwargs):
fake = Faker()
count = kwargs['count']
students = []
for _ in range(count):
students.append(
Student(
first_name=fake.first_name(),
last_name=fake.last_name(),
age=random.randint(20, 60),
))
Student.objects.bulk_create(students)
self.stdout.write(f'Created {count} students.')
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 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 create(self, validated_data):
regnumber = validated_data['regnumber']
email = validated_data['email']
first_name = validated_data['first_name']
last_name = validated_data['last_name']
password = validated_data['password']
user_obj = Student(
regnumber = regnumber,
email = email,
password = password,
first_name = first_name,
last_name = last_name,
)
user_obj.set_password(password)
user_obj.save()
return validated_data
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_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 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 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
