def account(request, account_id): try: acc = User.objects.get(id=int(account_id)) except: raise Http404 class AccountBaseForm(forms.ModelForm): class Meta: model = User fields = ["name", "surname", "number"] widgets = {"name": forms.TextInput(), "surname": forms.TextInput()} if request.method == "POST": form = AccountBaseForm(request.POST, instance=acc) if form.is_valid(): form.save() messages.add_message(request, messages.SUCCESS, u"Zapisano.") else: form = AccountBaseForm(instance=acc) if acc.status != 0: return render_to_response( "radmin/manage_accounts_acc.html", request, **klist(account=acc, selected_user_id=acc.id, form=form) ) else: return render_to_response( "radmin/manage_accounts_students_acc.html", request, account=acc, selected_user_id=acc.id, form=form, page=Paginator(User.objects.filter(status=0).order_by("surname", "name"), 30).page(1), )
def index(request, protocol_id=None): """@param protocol_id: TestResult.id or None""" # prepare test results tres = TestResult.objects.filter(written_by=request.user).order_by('-time_of_end') if protocol_id != None: protocol = TestResult.objects.get(id=int(protocol_id)) if protocol.written_by != request.user: raise Exception if not protocol.term.exam.test.can_review_mistakes: raise Exception proto_e = protocol.get_protocol() if proto_e != None: percentage = float(proto_e['score']) / float(proto_e['max_score']) * 100.0 else: percentage = None exam = protocol.term.exam return render_to_response('rstudent/protocol.html', request, results=tres, exam=exam, percentage=percentage, testresult=protocol, protocol=proto_e) else: return render_to_response('rstudent/proto_list.html', request, results=tres)
def supervise(request, exam_id, term_id): term = Term.objects.get(id=int(term_id)) if term.exam.id != int(exam_id): raise Exception if term.exam.owner != request.user: raise Exception return render_to_response('rteacher/term_supervise.html', request, term=term)
def join_group(request): if request.user.is_demo(): return redirect('/') # Calculate groups available for the student to join all_groups = set(Group.objects.filter(is_archival=False)) you_are_in = set(request.user.group_set.all()) you_want_to_be_in = set([x.group for x in JoinRequest.objects.filter(student=request.user)]) available_groups = all_groups.difference(you_are_in).difference(you_want_to_be_in) if request.method == 'POST': # Verify stuff try: group = Group.objects.get(id=int(request.POST['id'])) if group not in available_groups: raise Exception request.POST['description'] except: return redirect('/groups/join/') JoinRequest(student=request.user, group=group, reason=request.POST['description']).save() messages.add_message(request, messages.SUCCESS, u'Złożono podanie do grupy "%s"' % (group.name, )) return redirect('/groups/') return render_to_response('rstudent/groups_join.html', request, available=available_groups)
def term(request, exam_id, term_id): try: trm = Term.objects.get(id=int(term_id)) except: raise Http404 if trm.exam.group.teacher != request.user: return HttpResponse(status=403) class TermForm(forms.ModelForm): class Meta: model = Term fields = ['name', 'term_time'] if request.method == 'POST': form = TermForm(request.POST, instance=trm) if form.is_valid(): form.save() messages.add_message(request, messages.SUCCESS, u'Zapisano') else: form = TermForm(instance=trm) return render_to_response('rteacher/manage_exams_term.html', request, exam=trm.exam, term=trm, selected_exam_id=trm.exam.id, exams=Exam.objects.filter(owner=request.user), form=form)
def create(request): class NewAccountForm(forms.Form): _CHOICE = ((1, "Nauczyciel"), (2, "Adminstrator")) login = forms.EmailField(label=u"E-mail") name = forms.CharField(label=u"Imię", required=False) surname = forms.CharField(label=u"Nazwisko", required=False) status = forms.ChoiceField(choices=_CHOICE, initial=1, label=u"Typ") if request.method == "POST": form = NewAccountForm(request.POST) if form.is_valid(): # grab a random password from random import choice randompass = "".join([choice("1234567890qwertyupasdfghjklzxcvbnm") for i in range(7)]) u = User( login=form.cleaned_data["login"], name=form.cleaned_data["name"], surname=form.cleaned_data["surname"], status=form.cleaned_data["status"], ) u.save() u.set_password(randompass) messages.add_message(request, messages.SUCCESS, u"Konto stworzone. Nowe hasło to %s" % (randompass,)) return redirect("/admin/accounts/%s/" % (u.id,)) else: form = NewAccountForm() return render_to_response("radmin/manage_accounts_add.html", request, **klist(selected_user_id="create", form=form))
def gentable(request, exam_id): exam = Exam.objects.get(id=int(exam_id)) # Gotta get all people that written that and their results written = set() results = set() terms = list(exam.term_set.all().order_by('term_time')) for term in terms: s = list(term.testresult_set.all()) results = results.union(s) written = written.union([x.written_by for x in s]) written = list(written) written.sort(key=lambda x: u'%s %s' % (x.name, x.surname)) def lutfor(user, term): """Return None if not present or grade""" for res in results: if (res.written_by == user) and (res.term == term): return res.grade xtab = [] # list of list (surname, name, number, list of (grades for respective terms)) for user in written: grades = [lutfor(user, term) for term in terms] xtab.append([user.surname, user.name, user.number, grades]) return render_to_response('rteacher/gentable.html', request, exam=exam, xtab=xtab, terms=terms, writers=written)
def create(request): class NewGroupForm(forms.Form): name = forms.CharField(max_length=30, label=u'Nazwa') description = forms.CharField(required=True, label=u'Opis', widget=forms.TextInput()) if request.method == 'POST': form = NewGroupForm(request.POST) if form.is_valid(): g = Group(teacher=request.user, name=form.cleaned_data['name'], description=form.cleaned_data['description']) g.save() messages.add_message(request, messages.SUCCESS, u'Grupa utworzona') return redirect('/teacher/groups/%s/' % (g.id, )) else: form = NewGroupForm() return render_to_response('rteacher/manage_groups_add.html', request, **klist( selected_group_id='create', request=request, form=form))
def profile(request): class ProfileForm(forms.ModelForm): class Meta: model = User class ChangePasswordForm(forms.Form): current_pwd = forms.CharField(widget=forms.PasswordInput, label=u'Aktualne hasło') new_pwd = forms.CharField(widget=forms.PasswordInput, label=u'Nowe hasło') new_pwd2 = forms.CharField(widget=forms.PasswordInput, label=u'Potwierdź nowe') def __init__(self, request, *args, **kwargs): super(ChangePasswordForm, self).__init__(*args, **kwargs) self.user = request.user def clean(self): cleaned_data = super(ChangePasswordForm, self).clean() if not self.user.does_password_match(cleaned_data['current_pwd']): raise forms.ValidationError(u'Błędne hasło aktualne') if cleaned_data['new_pwd'] != cleaned_data['new_pwd2']: raise forms.ValidationError(u'Hasła nie zgadzają się!') return cleaned_data if request.method == 'POST': cpf = ChangePasswordForm(request, request.POST) if cpf.is_valid(): request.user.set_password(cpf.cleaned_data['new_pwd']) messages.add_message(request, messages.SUCCESS, u'Hasło zmienione.') else: cpf = ChangePasswordForm(request) return render_to_response('profile.html', request, cpf=cpf)
def create_category(request, test_id): try: test = Test.objects.get(id=int(test_id)) except: raise Http404 if test.owner != request.user: return HttpResponse(status=403) class NewCategoryForm(forms.Form): name = forms.CharField(label=u'Nazwa') if request.method == 'POST': form = NewCategoryForm(request.POST) if form.is_valid(): c = Category(test=test, name=form.cleaned_data['name']) c.save() messages.add_message(request, messages.SUCCESS, u'Dodano kategorię "%s"' % (c.name, )) return redirect('/teacher/tests/%s/category/%s/' % (test.id, c.id)) else: form = NewCategoryForm() return render_to_response('rteacher/tests_category_add.html', request, test=test, creating_new_category=True, form=form)
def group(request, group_id): try: grp = Group.objects.get(id=int(group_id)) except: raise Http404 if grp.teacher != request.user: return HttpResponse(status=403) class GroupForm(forms.ModelForm): class Meta: model = Group fields = ['name', 'description', 'is_archival'] if request.method == 'POST': form = GroupForm(request.POST, instance=grp) if form.is_valid(): form.save() messages.add_message(request, messages.SUCCESS, u'Zapisano') else: form = GroupForm(instance=grp) return render_to_response('rteacher/manage_groups_grp.html', request, **klist( group=grp, request=request, form=form))
def test(request, test_id): try: test = Test.objects.get(id=int(test_id)) except: raise Http404 if test.owner != request.user: return HttpResponse(status=403) class TestGradingForm(forms.ModelForm): class Meta: model = Test fields = ('g3_starts_at', 'g35_starts_at', 'g4_starts_at', 'g45_starts_at', 'g5_starts_at') if request.method == 'POST': form = TestGradingForm(request.POST, instance=test) if form.is_valid(): messages.add_message(request, messages.SUCCESS, u'Zapisano zmiany') form.save() else: form = TestGradingForm(instance=test) return render_to_response('rteacher/tests_test.html', request, form=form, test=test)
def requests(request, group_id): try: grp = Group.objects.get(id=int(group_id)) except: raise Http404 if grp.teacher != request.user: return HttpResponse(status=403) if request.method == 'POST': try: jr = JoinRequest.objects.get(id=int(request.POST['request_id'])) request.POST['action'] if jr.group != grp: raise Exception except: return redirect('/teacher/groups/%s/requests/' % (grp.id, )) if request.POST['action'] == 'confirm': jr.execute() messages.add_message(request, messages.SUCCESS, u'Zaakceptowano') else: jr.delete() messages.add_message(request, messages.SUCCESS, u'Usunięto wniosek') return redirect('/teacher/groups/%s/requests/' % (grp.id, )) return render_to_response('rteacher/manage_groups_requests.html', request, **klist( selected_group_id=grp.id, request=request, group=grp))
def view_students(request, page="1"): page = int(page) students = User.objects.filter(status=0).order_by("surname", "name") students = [x for x in students if not x.is_demo()] p = Paginator(students, 30) cpage = p.page(page) return render_to_response("radmin/manage_accounts_students_list.html", request, page=cpage)
def create(request): class NewTestForm(forms.Form): name = forms.CharField(label=u'Nazwa') can_go_back = forms.BooleanField(label=u'Można się cofać?', required=False) is_time_per_question = forms.BooleanField(label=u'Pytania determinują czas', required=False) is_multichoice = forms.BooleanField(label=u'Test wielokrotnego wyboru?', required=False) can_review_mistakes = forms.BooleanField(label=u'Czy można przejrzeć wyniki?', required=False) is_demo = forms.BooleanField(label=u'Dostępne dla konta demonstracyjnego?', required=False) time = forms.IntegerField(label=u'Czas (w sekundach) na wykonanie', required=False) def clean(self): data = super(NewTestForm, self).clean() try: is_time_per_question = data.get('is_time_per_question') time = data.get('time') except KeyError: return data if not is_time_per_question: try: int(time) except: self._errors['time'] = self.error_class([u'Pole wymagane']) return data if request.method == 'POST': form = NewTestForm(request.POST) if form.is_valid(): t = Test(owner=request.user, name=form.cleaned_data['name'], time=form.cleaned_data['time'], is_demo=form.cleaned_data['is_demo'], can_go_back=form.cleaned_data['can_go_back'], can_review_mistakes=form.cleaned_data['can_review_mistakes'], is_multichoice=form.cleaned_data['is_multichoice'], is_time_per_question=form.cleaned_data['is_time_per_question']) t.save() messages.add_message(request, messages.SUCCESS, u'Dodano test "%s"' % (t.name, )) return redirect('/teacher/tests/%s/' % (t.id, )) else: form = NewTestForm() return render_to_response('rteacher/tests_add.html', request, form=form)
def category(request, test_id, category_id): try: test = Test.objects.get(id=int(test_id)) category = Category.objects.get(id=int(category_id)) except: raise Http404 if test.owner != request.user: return HttpResponse(status=403) if category.test != test: return HttpResponse(status=403) return render_to_response('rteacher/tests_category.html', request, test=test, category=category)
def protocol(request, testresult_id): tres = get_object_or_404(TestResult, id=int(testresult_id)) if tres.term.exam.owner != request.user: return HttpResponse(status=403) proto = tres.get_protocol() try: percentage = round(float(proto['score']) / float(proto['max_score']) * 100.0, 2) except: percentage = None return render_to_response('rteacher/protocol.html', request, protocol=proto, percentage=percentage, testresult=tres, term=tres.term, exam=tres.term.exam)
def setup(request, exam_id, term_id): try: trm = Term.objects.get(id=int(term_id)) except: raise Http404 if trm.exam.group.teacher != request.user: return HttpResponse(status=403) if trm.is_closed or trm.is_progressing: return HttpResponse(status=400) return render_to_response('rteacher/term_setup.html', request, term=trm, exam=trm.exam, students=get_applicable_students(trm))
def login(request): """Handles logging in Required by the client. Will only allow teachers and admins to log in""" class LoginForm(forms.Form): login = forms.EmailField(max_length=254, label=u'Email') password = forms.CharField(widget=forms.PasswordInput, label=u'Hasło', required=True) def clean(self): cleaned_data = super(LoginForm, self).clean() login, password = cleaned_data.get('login'), cleaned_data.get('password') if not login: return cleaned_data if not password: return cleaned_data try: usr = User.objects.get(login=login) except User.DoesNotExist: raise forms.ValidationError(u'Nie ma takiego użytkownika') if not usr.does_password_match(password): raise forms.ValidationError(u'Błędne hasło') if usr.status == 0: raise forms.ValidationError(u'Logowanie zabronione') return cleaned_data if request.method == 'POST': rf = LoginForm(request.POST) if rf.is_valid(): request.login(rf.cleaned_data['login']) # Log in the user messages.add_message(request, messages.INFO, u'Zalogowano.') return redirect('/') else: rf = LoginForm() return render_to_response('front/login_radmin.html', request, form=rf)
def addterm(request, exam_id): try: exam = Exam.objects.get(id=int(exam_id)) except: raise Http404 if exam.group.teacher != request.user: return HttpResponse(status=403) class NewTermForm(forms.ModelForm): class Meta: model = Term fields = ('name', 'term_time') def clean_term_time(self): term_time = form.cleaned_data['term_time'] from datetime import datetime if term_time < datetime.now(): raise forms.ValidationError(u'Termin musi wypadać w przyszłości') return term_time if request.method == 'POST': form = NewTermForm(request.POST) if form.is_valid(): inst = form.instance inst.exam = exam inst.save() messages.add_message(request, messages.SUCCESS, u'Termin utworzony') return redirect('/teacher/exams/%s/terms/%s/' % (exam.id, inst.id, )) else: form = NewTermForm() return render_to_response('rteacher/manage_exams_addterm.html', request, selected_exam_id=exam.id, form=form, exam=exam, exams=Exam.objects.filter(owner=request.user))
def index(request): """Determines user role and redirects him to suitable page""" if request.user == None: # not logged in return render_to_response('front/index.html', request) if request.user.status == 0: # student from athena.rstudent.views import index return index(request) if request.user.status == 1: # student from athena.rteacher.views import index return index(request) if request.user.status == 2: # student from athena.radmin.views import index return index(request)
def create(request): class NewExamForm(forms.ModelForm): class Meta: model = Exam exclude = ('owner', ) def __init__(self, *args, **kwargs): tests = kwargs.pop('tests') groups = kwargs.pop('groups') super(NewExamForm, self).__init__(*args, **kwargs) self.fields['test'].queryset = tests self.fields['group'].queryset = groups tests = Test.objects.filter(owner=request.user) groups = Group.objects.filter(teacher=request.user) if request.method == 'POST': form = NewExamForm(request.POST, tests=tests, groups=groups) if form.is_valid(): form.instance.owner = request.user form.save() messages.add_message(request, messages.SUCCESS, u'Egzamin utworzony') return redirect('/teacher/exams/%s/' % (form.instance.id, )) else: form = NewExamForm(tests=tests, groups=groups) return render_to_response('rteacher/manage_exams_add.html', request, selected_exam_id='create', form=form, exams=Exam.objects.filter(owner=request.user))
def members(request, group_id): try: grp = Group.objects.get(id=int(group_id)) except: raise Http404 if grp.teacher != request.user: return HttpResponse(status=403) if request.method == 'POST': try: student = User.objects.get(id=int(request.POST['user_id'])) grp.students.remove(student) except: return redirect('/teacher/groups/%s/members/' % (grp.id, )) messages.add_message(request, messages.SUCCESS, u'Usunięto studenta z grupy') return redirect('/teacher/groups/%s/members/' % (grp.id, )) return render_to_response('rteacher/manage_groups_members.html', request, **klist( selected_group_id=grp.id, request=request, group=grp))
def list(request): """Displays a list of all groups""" return render_to_response('rteacher/manage_groups_list.html', request, **klist( request=request ))
def index(request): return render_to_response('rstudent/index.html', request, demos=Test.objects.filter(is_demo=True))
def groups(request): return render_to_response('rstudent/groups.html', request, you_are_in=request.user.group_set.all(), you_want_to_be_in=JoinRequest.objects.filter(student=request.user))
def index(request): return render_to_response('radmin/index.html', request)
def list(request): return render_to_response("radmin/manage_accounts_list.html", request, **klist())
def list(request): """Displays a list of all groups""" return render_to_response('rteacher/manage_exams_list.html', request, exams=Exam.objects.filter(owner=request.user) )
def about(request): return render_to_response('front/about.html', request)