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)
