Esempio n. 1
0
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()
Esempio n. 2
0
    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)
Esempio n. 3
0
    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)
Esempio n. 4
0
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
Esempio n. 5
0
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
Esempio n. 6
0
    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()
Esempio n. 7
0
 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)
Esempio n. 8
0
    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)
Esempio n. 9
0
 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)
Esempio n. 10
0
File: views.py Progetto: GOLDKUM/KUM
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'))
Esempio n. 11
0
    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)
Esempio n. 12
0
 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
Esempio n. 13
0
	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))
Esempio n. 14
0
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
        })
Esempio n. 15
0
    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()
Esempio n. 16
0
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)
Esempio n. 17
0
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")
Esempio n. 18
0
	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)
Esempio n. 19
0
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'))
Esempio n. 20
0
	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)
Esempio n. 21
0
	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))
Esempio n. 22
0
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)
Esempio n. 23
0
 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
Esempio n. 24
0
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'))
Esempio n. 25
0
 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 deleted: Demo Student (ID: %d)\n' % sid)
     # remove our handler from root logger
     logging.root.removeHandler(handler)
Esempio n. 26
0
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'})
Esempio n. 27
0
 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')
Esempio n. 28
0
def stu_details(request):
    if request.method == 'POST':
        if request.POST.get('usn') != None and request.POST.get(
                'name') != None and request.POST.get(
                    'sem') != None and request.POST.get('dept') != None:
            print("Hie")
            form = Student()
            form.USN = request.POST['usn']
            form.name = request.POST['name']
            form.sem = request.POST['sem']
            form.Dept = request.POST['dept']
            form.save()
            return redirect('accounts:signup')

    else:
        form = Student

    return render(request, 'accounts/student_details.html')
Esempio n. 29
0
def insertStudents(request):
    print("This is the insert Excel page")
    connection = sqlite3.connect('students.db')
    cursor = connection.cursor()
    if request.method == "POST":
        data = request.POST.copy()
        student=Student()
        student.room_no = data.get('room_no')
        student.block = data.get('block')
        student.name = data.get('name')
        student.mob_no = data.get('mob_no')
        student.id_no = data.get('id_no')
        print(student.room_no)
        student.save()
        #sql_insert_single = "INSERT INTO students(ROOMNO, BLOCK, STUDENT, MOBILE, ID) VALUES('{0}', '{1}', '{2}', '{3}', '{4}')".format(room_no, block, student, mobile, id)
        #cursor.execute(sql_insert_single)
        connection.commit()
        connection.close()
    return render(request, 'insertStudentExcel.html')
Esempio n. 30
0
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})
Esempio n. 31
0
 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()
Esempio n. 32
0
    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)
Esempio n. 33
0
    def post(self, request):
        data = json.loads(request.body.decode('utf-8'))
        print(data)
        # myfile = request.FILES.get('filename')
        code = data['code']
        firstName = data['firstName']
        # lastName = request.POST.get('lastName')
        email = data['email']
        # dob = request.POST.get('dob')
        route = data['route']
        address = data['address']
        # student = Student(code=code, firstName=firstName, lastName=lastName,email=email, dob=dob, route=route, address=address, image=myfile)
        student = Student(code=code,
                          firstName=firstName,
                          email=email,
                          route=route,
                          address=address)
        student.save()

        return redirect('/students')
Esempio n. 34
0
def add(request):
    if request.method == "POST":
        form = request.POST
        student = Student()
        student.name = form['name']
        student.registration_number = form['registration_number']
        student.address = form['address']
        student.age = form['age']
        #1
        student.school = School.objects.get(pk=form['school'])
        student.save()

        return redirect('students:student_detail',student.pk)
    
    

    schools = School.objects.all()
    context = {'schools': schools}

    return render(request, 'students/addStudent.html',context)
Esempio n. 35
0
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)
Esempio n. 36
0
def student_add(request):
    if request.method == 'POST':
        form = StudentForm(request.POST)
        if form.is_valid():
            student = Student()
            student.name = form.cleaned_data['student_name']
            student.surname = form.cleaned_data['student_surname'],
            student.email = form.cleaned_data['student_email'],
            student.phone = form.cleaned_data['student_phone'],
            student.package = form.cleaned_data['student_package']
            student.save()
            return redirect('Student_list')
    else:
        form = StudentForm(initial={
            'student_name': '',
            'student_surname': '',
            'student_email': '',
            'student_phone': '',
            'student_package': '',
        })
    return render(request,'students/edit.html', {'form': form})
Esempio n. 37
0
    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)
Esempio n. 38
0
def ajax_add_student(request):

    name = request.POST.get('name')
    address = request.POST.get('address')
    phone = request.POST.get('phone')
    birth = request.POST.get('birth')
    school = request.POST.get('school')
    money = request.POST.get('money')
    created = datetime.datetime.now()
    updated = datetime.datetime.now()

    s = Student(name=name,
                address=address,
                phone=phone,
                birth=birth,
                school=school,
                money=money,
                created=created,
                updated=updated)
    s.save()
    # Нужно еще добавить поля
    return HttpResponse('Создано')
Esempio n. 39
0
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)
Esempio n. 40
0
 def test_Entry_Fields_Links(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/')
     self.assertContains(response, 'Django Base')
     self.assertContains(response, '/students/edit/{}/'.format(student.id))
     self.assertContains(response, '/students/remove/{}/'.format(student.id))
     self.assertContains(response, '/students/add/')
     self.assertEqual(student.name, "Ivan")
     self.assertEqual(student.date_of_birth, "1999-09-09")
     self.assertEqual(course.name, 'Django Base')
     self.assertEqual(student.courses.all()[0], course)
Esempio n. 41
0
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 )
Esempio n. 42
0
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)
Esempio n. 43
0
def addStudent(request):

    if request.method == 'GET':
        return HttpResponse(render(request, 'add_student.html'))
    elif request.method == 'POST':

        name = request.POST.get('name')
        surname = request.POST.get('surname')
        avg_mark = request.POST.get('avg_mark')
        group_id = request.POST.get('group_id')

        if int(avg_mark) > 9:
            group_id = 2

        student = Student()

        student.name = name
        student.surname = surname
        student.avg_mark = avg_mark
        student.group_id = group_id

        student.save()

    return redirect('/groups/all')
Esempio n. 44
0
class BadgeTests(TestCase):
    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
    
    # Test the model's "held_by" method.
    def test_held_by(self):
        self.assertFalse( self.b.held_by( self.ishara ) )
        self.assertTrue( self.b.held_by( self.alexis ) )
    
    # When an anonymous user visits the badge list (/badges/) they see the
    # superbadge.
    def test_view_badge_list(self):
        response = self.c.get('/badges/')
        self.assertEqual(response.status_code, 200)
        response = self.c.get('/badges/superbadge/')
        self.assertEqual(response.status_code, 200)
    
    # When you go to a badge that doesn't exist, you get redirected back to
    # '/badges'.
    def test_badge_redirect(self):
        response = self.c.get('/badges/fakebadge/', follow=True)
        self.assertEqual(response.redirect_chain, [(u'http://testserver/badges/', 302)])

    # When Alexis visits the badge list, she sees a check mark next to
    # the superbadge.
    def test_view_badge_list_check(self):
        self.c.login(username="******", password="******")
        response = self.c.get('/badges/')
        self.assertEqual(response.status_code, 200)
        self.assertTrue( '<i class="icon-ok"></i>' in response.content )

    # When Ishara visits the badge list, he doesn't see a check mark next to
    # the superbadge.
    def test_view_badge_list_nocheck(self):
        self.c.login(username="******", password="******")
        response = self.c.get('/badges/')
        self.assertEqual(response.status_code, 200)
        self.assertFalse( '<i class="icon-ok"></i>' in response.content )
    
    # When Alexis visits the badge information, she can add the badge to her
    # backpack.
    def test_badge_backpack_button(self):
        self.c.login(username="******", password="******")
        response = self.c.get('/badges/superbadge/')
        self.assertEqual(response.status_code, 200)
        self.assertTrue( 'http://beta.openbadges.org/issuer.js' in response.content )

    # When Ishara visits the badge information, he can not add the badge to his
    # backpack.
    def test_view_badge_list_nocheck(self):
        self.c.login(username="******", password="******")
        response = self.c.get('/badges/superbadge/')
        self.assertEqual(response.status_code, 200)
        self.assertFalse( 'http://beta.openbadges.org/issuer.js' in response.content )    
    
    # Check to ensure that you get a 404 for the assertion for Ishara and a
    # JSON string for Alexis.
    def test_badge_assertion(self):
        response = self.c.get('/badges/superbadge/ishara/')
        self.assertEqual(response.status_code, 404)
        response = self.c.get('/badges/superbadge/ramen/')
        self.assertEqual(response.status_code, 404)
        response = self.c.get('/badges/superbadge/alexis/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response['Content-Type'], 'application/json')
Esempio n. 45
0
class LessonTests(TestCase):
    def setUp(self):
        self.c = Client()
        self.t1 = Page( title="index",
                        content="sup" )
        self.t2 = Page( title="epic",
                        content="""
                        = This is a truly epic tale.
                        == OMG
                        === fur reals
                          
                        It stars **Ishara** //Alexis// and __Allen__.
                         
                        --THE END--
                        """)
        self.t1.save()
        self.t2.save()

        # Let's create a world with three stages.
        self.W = World( name = "Fun World",
                        shortname = "1",
                        graphic = "foo" )
        self.W.save()
        self.Q = QuizChallenge( shortname = "quiz1",
                                content = "foo" )
        self.Q.save()
        self.l1 = Stage( name = "Fun Level 1",
                         shortname = "1",
                         lesson = self.t2,
                         challenge = self.Q,
                         world = self.W,
                         xlocation = 1,
                         ylocation = 1,
                         graphic = "foo")
        self.l2 = Stage( name = "Fun Level 2",
                         shortname = "2",
                         lesson = self.t2,
                         world = self.W,
                         xlocation = 1,
                         ylocation = 1,
                         graphic = "foo")
        self.l3 = Stage( name = "Fun Level 3",
                         shortname = "3",
                         challenge = self.Q,
                         world = self.W,
                         xlocation = 1,
                         ylocation = 1,
                         graphic = "foo",
                         hidden = True)
        self.l1.save()
        self.l2.save()
        self.l3.save()
        self.l2.prereqs.add(self.l1)
        self.l3.prereqs.add(self.l1)
        self.l2.save()
        self.l3.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()
        
        # Give the test users memorable names.
        self.ishara = self.s1
        self.alexis = self.s2
        
        self.l1.completed_by.add(self.alexis)
        self.l1.save()
       
    # Anonymous viewers can not access the pages - they will be redirected
    # to the log-in/sign-up page. 
    def test_anon_lessons(self):
        pass
    
    # When a user visits a stage that doesn't have a lesson, they go directly
    # to the challenge.
    def test_go_challenge(self):
        self.c.login(username="******", password="******")
        response = self.c.get("/world/1/3/", follow=True)
        self.assertEqual(response.redirect_chain, [(u'http://testserver/world/1/3/challenge/', 302)])
        response = self.c.get("/world/1/3/lesson/", follow=True)
        self.assertEqual(response.redirect_chain, [(u'http://testserver/world/1/3/challenge/', 302)])
        
    # When a user visits a stage that doesn't have a challenge, they go directly
    # to the lesson.
    def test_go_challenge(self):
        self.c.login(username="******", password="******")
        response = self.c.get("/world/1/2/", follow=True)
        self.assertEqual(response.redirect_chain, [(u'http://testserver/world/1/2/lesson/', 302)])
        response = self.c.get("/world/1/2/challenge/", follow=True)
        self.assertEqual(response.redirect_chain, [(u'http://testserver/world/1/2/lesson/', 302)])
    
    # Test the world map. Ishara will see two stages, while Alexis will see 3.
    def test_world_map(self):
        self.c.login(username="******", password="******")
        response = self.c.get("/world/1/")
        self.assertTrue( "Fun Level 3" in response.content )
        self.c.logout()
        self.c.login(username="******", password="******")
        response = self.c.get("/world/1/")
        self.assertFalse( "Fun Level 3" in response.content )
Esempio n. 46
0
    def handle(self, *args, **options):

        self.stdout.write(
            u'Function of automatic filling of the Database.' \
            u' How many objects need to create? ')

        # students
        if 'students' in args:
            number = int(raw_input(
                u'Input the number of students: '))
            for i in range(number):
                student = Student(
                    first_name=random.choice(self.first_names),
                    last_name=random.choice(self.last_names),
                    middle_name=random.choice(self.middle_names),
                    ticket=random.choice(
                        self.ticket) + random.choice(self.ticket),
                    student_group=Group.objects.all()[random.randint(
                        0, Group.objects.count() - 1)],
                    birthday=datetime.today())
                student.save()
                self.stdout.write(
                    u'Objects %s create in database' % student)

        # groups
        if 'groups' in args:
            number = int(raw_input(
                u'Input the number of groups: '))
            for i in range(number):
                group = Group(
                    title=random.choice(self.title),
                    leader=Student.objects.all()[random.randint(
                        0, Student.objects.count() - 1)], )
                group.save()
                self.stdout.write(
                    u'Objects %s create in database' % group)

        # exams
        if 'exams' in args:
            number = int(raw_input(
                u'Input the number of exams: '))
            for i in range(number):
                exam = Exam(
                    science=random.choice(self.science),
                    teacher=random.choice(self.teacher_names),
                    date=datetime.today(),
                    groups=Group.objects.all()[random.randint(
                        0, Group.objects.count() - 1)])
                exam.save()
                self.stdout.write(
                    u'Objects %s create in database' % exam)

        # results
        if 'results' in args:
            number = int(raw_input(
                u'Input the number of exam results '))
            for i in range(number):
                result = Result(
                    exams=Exam.objects.all()[random.randint(
                        0, Exam.objects.count() - 1)],
                    groups=Group.objects.all()[random.randint(
                        0, Group.objects.count() - 1)],
                    students=Student.objects.all()[random.randint(
                        0, Student.objects.count() - 1)],
                    result=random.choice(self.results))
                result.save()
                self.stdout.write(
                    u'Objects %s create in database' % result)
Esempio n. 47
0
def register_view(request):
    # make sure users that are logged in can't reach this
    if request.user.is_authenticated and request.user.is_active:
        return redirect('/')

    # grab all schools to pass onto registration form
    schools = School.objects.all()

    if request.method == 'POST':
        if request.POST['type'] == 'teacher':
            try:
                new_user = User.objects.create_user(
                    username=request.POST['username'],
                    first_name=request.POST['first_name'],
                    last_name=request.POST['last_name'],
                    password=request.POST['password'],
                    email=request.POST['email']
                )
            except IntegrityError as e:
                if str(e) == 'column username is not unique':
                    return render(request, 'auth/register.html', {
                        'schools': schools,
                        'error': 'Username is already taken.'
                    })
                else:
                    return render(request, 'auth/register.html', {
                        'schools': schools,
                        'error': 'Registration error. Please try again.'
                    })

            needs_tos = Permission.objects.get(codename='needs_tos')
            new_user.user_permissions.add(needs_tos)
            new_user.save()
            teacher_name = new_user.first_name + ' ' + new_user.last_name

            # grab the selected school model
            home_school = School.objects.get(pk=request.POST['school'])

            new_teacher = Teacher(school=home_school)
            new_teacher.save()

            z_user = ZerebralUser(user=new_user, teacher=new_teacher)
            z_user.save()

            new_user = authenticate(username=request.POST['username'], password=request.POST['password'])
            login(request, new_user)

            # send the welcome email
            send_teacher_welcome_email(teacher_name, new_user.email)

            return redirect('/accounts/tos')
        elif request.POST['type'] == 'student':
            try:
                new_user = User.objects.create_user(
                    username=request.POST['username'],
                    first_name=request.POST['first_name'],
                    last_name=request.POST['last_name'],
                    password=request.POST['password'],
                    email=request.POST['email']
                )
            except IntegrityError as e:
                if str(e) == 'column username is not unique':
                    return render(request, 'auth/register.html', {
                        'schools': schools,
                        'error': 'Username is already taken.'
                    })
                else:
                    return render(request, 'auth/register.html', {
                        'schools': schools,
                        'error': 'Registration error. Please try again.'
                    })

            needs_tos = Permission.objects.get(codename='needs_tos')
            new_user.user_permissions.add(needs_tos)
            new_user.save()
            student_name = new_user.first_name + ' ' + new_user.last_name

            # grab the existing parent or create a new one
            try:
                new_parent = Parent.objects.get(email__iexact=request.POST['parent_email'])
            except:
                new_parent = None

            try:
                if new_parent is None:
                    new_parent = Parent(
                        email=request.POST['parent_email'],
                        first_name=request.POST['parent_first_name'],
                        last_name=request.POST['parent_last_name']
                    )
                    new_parent.save()

                new_student = Student(
                    parent_token=generate_token(50),
                    parent=new_parent
                )
                new_student.save()
            except:
                new_user.delete()
                return render(request, 'auth/register.html', {
                    'schools': schools,
                    'error': "Please enter your parent's contact info."
               })

            # send email to parent for consent
            send_consent_email(
                request.build_absolute_uri('/parent/consent/'+new_student.parent_token),
                student_name,
                new_parent.email
            )

            z_user = ZerebralUser(user=new_user, student=new_student)
            z_user.save()

            new_user = authenticate(username=request.POST['username'], password=request.POST['password'])
            login(request, new_user)

            # send the welcome email
            send_student_welcome_email(student_name, new_user.email)

            return redirect('/accounts/tos')



    return render(request, 'auth/register.html', {'schools': schools})
Esempio n. 48
0
def sign_in(request):
    me = Student.from_request(request)
    if "alerts" not in request.session: request.session["alerts"] = []
    if me: return redirect("index")
    
    if request.method == "POST":
        if request.POST.get("sign-up") == "sign-up": return redirect("sign-up")
        elif "username" in request.POST and "password" in request.POST:
            username = request.POST.get("username")
            password = request.POST.get("password")
            user = authenticate(username=username, password=password)
            if user is not None:
                if Student.objects.filter(user=user).exists():
                    login(request, user)
                    s = user.student
                    s.last_login = s.this_login
                    s.this_login = timezone.now()
                    if s.last_login is None:
                        s.last_login = s.this_login
                    if s.last_login.day != s.this_login.day:
                        s.modpoints = s.level
                    s.save()
                    return redirect("index")
                else:
                    request.session["alerts"].append(("alert-error",
                                                      """This account has not yet
                                                      been activated. Please check
                                                      your e-mail for the activation
                                                      link."""))
                    return redirect("sign-in")
            else:
                request.session["alerts"].append(("alert-error",
                                                  """Incorrect username or
                                                  password."""))
                return redirect("sign-in")
        else: return redirect("sign-in")
    elif "key" in request.GET and "username" in request.GET:
        key = request.GET["key"]
        username = request.GET["username"]
        
        # Redirect to login if the user account does not exist or has already
        # been activated.
        try: user = User.objects.get(username=username)
        except exceptions.ObjectDoesNotExist: return redirect("sign-in")
        if Student.objects.filter(user=user).exists(): return redirect("sign-in")
        
        # Verify the hash and redirect if it doesn't match.
        if hashlib.sha256(username+settings.REGISTER_SALT).hexdigest() != key:
            return redirect("sign-in")
        
        # Assuming everything went well...
        S = Student( user=user )
        S.save()
        user.is_active = True
        user.save()
        request.session["alerts"].append(("alert-success",
                                          """Verification successful! You may
                                          now sign in!."""))
        return render(request, "sign-in.html", {'alerts': request.session.pop('alerts', []) })
    else:
        return render(request, "sign-in.html", {'alerts': request.session.pop('alerts', []) })
Esempio n. 49
0
class StudentModelTests(TestCase):

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

    def test_student_create(self):
        """Ensure creating of a student object works"""
        stud1 = Student.objects.create(
            prename='Cora',
            name='Nickerson',
            email='*****@*****.**',
            tutor_group=self.tg,
            want_exam=True,
        )

        stud1.save()

        # check that save works
        self.assertEqual(stud1.prename, 'Cora')
        self.assertEqual(stud1.name, 'Nickerson')
        self.assertEqual(stud1.tutor_group, self.tg)
        self.assertEqual(stud1.want_exam, True)
        self.assertEqual(stud1.ophase, self.o1)

        # test __str__
        tg_string = self.tg.__str__()
        self.assertEqual(stud1.__str__(), 'Nickerson, Cora (%s)' % (tg_string))

        # The E-Mail is stored even if the student did not select any
        # newsletter
        self.assertEqual(stud1.email, '*****@*****.**')
        
        self.assertEqual(stud1.want_newsletter(), False)

        # Add a newsletter
        self.n1.save()
        stud1.newsletters.add(self.n1)
        self.assertEqual(stud1.want_newsletter(), True)
        

    def test_student_update(self):
        """Ensure update of a student object works"""

        stud1 = self.st

        stud1.save()

        # check values
        self.assertEqual(stud1.prename, 'John')
        self.assertEqual(stud1.name, 'Doe')
        self.assertEqual(stud1.email, '*****@*****.**')
        self.assertEqual(stud1.tutor_group, self.tg)
        self.assertEqual(stud1.want_exam, True)
        self.assertEqual(stud1.ophase, self.o1)

        stud1.prename = 'John Peter'

        stud1.save()

        self.assertEqual(stud1.prename, 'John Peter')
        self.assertEqual(stud1.name, 'Doe')
        self.assertEqual(stud1.email, '*****@*****.**')
        self.assertEqual(stud1.tutor_group, self.tg)
        self.assertEqual(stud1.want_exam, True)
        self.assertEqual(stud1.ophase, self.o1)

    def test_student_foreign_key_ophase(self):
        """Ensure Student is created with active Ophase as ForeignKey."""
        # create Student with an active Ophase
        self.st.save()
        self.assertEqual(self.st.ophase.name, "Testophase 1")
        # create another Ophase which is active (i.e. old Ophase becomes inactive) and update old Person
        # Ophase ForeignKey should stay the same as before!
        Ophase.objects.create(name="Testophase 2", is_active=True)
        self.o1.is_active = False
        self.o1.save()

        self.st.email = "*****@*****.**"
        self.st.save()
        st = Student.objects.get(pk=self.st.pk)
        self.assertEqual(st.ophase.name, "Testophase 1")
        self.assertEqual(st.email, "*****@*****.**")

        self.assertEqual(Student.objects.count(), 1)

        # Delete the Ophase object
        self.o1.delete()

        # The students object should be deleted too
        self.assertEqual(Student.objects.count(), 0)
Esempio n. 50
0
File: dummy.py Progetto: itao/wnw
def init():
    print 'Existing database will be wiped, continue? (y/n)'
    choice = raw_input().strip()
    if choice == 'y':

        print 'Working...'

        # Wipe db
        clean()

        # Common variable
        pw = 'sesame'
        # FYI
        ACCOUNT_TYPES = {
            1: 'teacher',
            2: 'student',
            3: 'parent',
        }

        # Create teachers
        t = Teacher(first_name='Sesame', last_name='Teacher', email='*****@*****.**', user_type=1)
        t.save()
        t.set_password(pw)
        t.save()

        # Create classes
        for i in range(3):
            index = str(i+1)
            name = 'Class #' + index
            code = 'KLS' + index
            start = end = datetime.now().date()
            colour = "#" + index*6

            k = Klass(teacher=t, name=name, code=code, start=start, end=end, colour=colour)
            k.save()

        # Create students
        students = [
            {
                'first_name': 'Alton',
                'last_name': 'Lau',
                'email': '*****@*****.**'
            }, {
                'first_name': 'Marc',
                'last_name': 'Lo',
                'email': '*****@*****.**'
            }, {
                'first_name': 'Madigan',
                'last_name': 'Kim',
                'email': '*****@*****.**'
            }
        ]
        classes = Klass.objects.all()
        for i in range(3):
            s = students[i]
            s = Student(first_name=s['first_name'], last_name=s['last_name'], email=s['email'], user_type=2)
            s.save()
            s.set_password(pw)
            s.save()
            s.klasses = classes[:i+1]


        k = Klass.objects.all()[0]
        s = Student.objects.all()
        # Create notes
        for i in range(3):
            index = str(i+1)
            detail = 'This is note #' + index
            n = Note(klass=k, detail=detail)
            n.save()
            n.students = s[:i+1]
        print 'All done, goodbye!'
    else:
        print 'Fine, I see how it is.'
Esempio n. 51
0
def handle_oauth(request):
    me = Student.from_request(request)
    
    # Github will give us a code. If we don't get the code or if the secrets
    # have been screwed up, fail early.
    if ("code" not in request.GET or request.session.get("secret_state") is None
       or request.GET.get("state") != request.session.get("secret_state")):
        request.session["alerts"].append(("alert-error","Error getting token from Github."))
        return redirect("index")    
    
    # Send the data to Github and get our token!
    keys = (settings.GITHUB_ID, settings.GITHUB_SECRET, request.GET["code"])
    try: response = urllib2.urlopen('https://github.com/login/oauth/access_token',
                                    'client_id=%s&client_secret=%s&code=%s'%keys)
    except:
        request.session["alerts"].append(("alert-error","Error getting token from Github."))
        return redirect("index") 
                               
    data = response.read()
    if "access_token" not in data:
        request.session["alerts"].append(("alert-error","Error getting token from Github."))
        return redirect("index")    
    
    # Get the token.
    token = data[data.find("=")+1:data.find("&")]
    request.session["access_token"] = token
    
    # Now, we find out the user's name and e-mail address. If this user has an
    # account, we log them in. If not, we create an account for them.
    try:
        response = urllib2.urlopen('https://api.github.com/user?access_token=%s'%token)
        userdata = json.loads(response.read())
        username = userdata["login"]
        try: user = User.objects.get(username=username)
        except exceptions.ObjectDoesNotExist:
            user = None
            response = urllib2.urlopen('https://api.github.com/user/emails?access_token=%s'%token)
            emaildata = json.loads(response.read())
            email = emaildata[0]
    except:
        request.session["alerts"].append(("alert-error","Error getting token from Github."))
        return redirect("index")   
    
    # Get the user and username. If the user is in the db, log it in. Otherwise,
    # create an account.
    
    
    # Log in or create the account.
    if user and not user.student.banned:
        user.backend = 'django.contrib.auth.backends.ModelBackend'
        login(request, user)
        user.student.unread_since = user.student.last_login
        user.student.last_login = timezone.now()
        user.student.save()
        request.session["alerts"].append(("alert-success","Welcome back, %s!"%username))
        return redirect("index")
    elif user and user.student.banned:
        request.session["alerts"].append(("alert-error","""This account has
                                          been suspended. If you believe this
                                          is in error, please contact the site
                                          administrator."""))
        return redirect("index")
    elif settings.NO_NEW_ACCOUNTS:
        request.session["alerts"].append(("alert-error","""New account creation is not
                                          enabled at this time. Please try again in the
                                          future!"""))
        return redirect("index")
    else:
        user = User.objects.create_user(username, email, 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")