class CustomAuthTokenSerializer(serializers.Serializer):
"""
A custom serializer to handle the transfer of the AuthToken data over the api
"""
email = serializers.EmailField(label=lazy("Email"))
password = serializers.CharField(label=lazy("Password"),
style={'input_type': 'password'})
def validate(self, attrs):
email = attrs.get('email')
password = attrs.get('password')
if email and password:
user = authenticate(email=email, password=password)
if user:
if not user.is_active:
msg = lazy("This account has been disabled")
raise serializers.ValidationError(msg,
code='authorization')
else:
msg = lazy("Unable to log in with the provided credentials.")
raise serializers.ValidationError(msg, code="authorization")
else:
msg = lazy('Cannot authorize with "username" and "password".')
raise serializers.ValidationError(msg, code='authorization')
attrs['user'] = user
return attrs
def clean(self, *args, **kwargs):
data = super(AudioFileField, self).clean(*args, **kwargs)
file = data.file
if file:
try:
file_type = file.content_type
print(file_type)
# ensure file is valid type
if file_type in [
'audio/mpeg3',
'audio/mpeg',
'audio/x-mpeg-3',
'audio/mp3',
]:
# ensure file is below maximum size
if file._size > self.max_upload_size:
raise forms.ValidationError(
lazy('File is greater than maximum allowed size'))
else:
raise forms.ValidationError(lazy('File is not an Mp3'))
except AttributeError:
pass
else:
raise forms.ValidationError(lazy('No File Read'))
return data
def create_superuser(self, email: str, password: str,
**params: Union[str, Any]) -> Type[BaseUserManager]:
params.setdefault('is_staff', True)
params.setdefault('is_superuser', True)
params.setdefault('is_active', True)
if params.get('is_staff') is not True:
raise ValueError(lazy('superuser must have a is_staff=True'))
if params.get('is_superuser') is not True:
raise ValueError(lazy('superuser must have a is_superuser=True'))
return self.create_user(email, password, **params)
class ExamUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Exam
form_class = CreateExam
template_name = 'teacher/createExam.html'
extra_context = {
'title': lazy('Update Exam')
}
def form_valid(self, form):
form.instance.teacher = self.request.user
self.request.session['exam_number_of_questions'] = form.cleaned_data['exam_number_of_questions']
print('here in valid',self.request.session['exam_number_of_questions'])
return super().form_valid(form)
def test_func(self):
exam = self.get_object()
if self.request.user == exam.teacher:
return True
return False
def get_success_url(self):
self.request.session['updated_exam_id'] = self.get_object().id
return '/teacher/exam/update-questions/'
class AllExamsListView(ListView):
model = Exam
template_name = 'teacher/all_exams_list.html'
context_object_name = 'exams'
ordering = ['-exam_date']
extra_context = {
'title': lazy("All Exams")
}
class LettingAdmin(modelclone.ClonableModelAdmin):
clone_verbose_name = lazy("Renew Letting")
inlines = [PaymentScheduleInline]
list_display = (
"get_tenant_name",
"type",
"letting_duration",
"start_date",
"end_date",
"amount_paid",
"amount_outstanding",
"cost",
"schedule_type",
"active",
)
list_filter = ("active",)
search_fields = ["tenant__first_name", "tenant__last_name"]
fieldsets = (
(
"Basic",
{
"fields": (
"tenant",
"realty",
"type",
"duration",
"start_date",
"cost",
"schedule_type",
"service_charge",
"active",
)
},
),
("Deposit", {"fields": ("deposit", "deposit_refunded", "deposit_refund_date")}),
("Default", {"fields": ("defaulting_amount", "defaulting_description")}),
)
def get_tenant_name(self, obj):
return " ".join([obj.tenant.first_name, obj.tenant.last_name])
def letting_duration(self, instance):
if instance.duration:
return f"{instance.duration} month(s)"
def tweak_cloned_fields(self, fields):
instance = core_models.Letting.objects.get(id=fields["id"])
end_date = instance.end_date
fields["start_date"] = pendulum.date(end_date.year, end_date.month, end_date.day).add(days=1)
return fields
get_tenant_name.short_description = "Tenant Name"
get_tenant_name.admin_order_field = "tenant"
letting_duration.short_description = "Duration"
def create_user(self, email: str, password: str,
**kwargs: Union[str, Any]) -> Type[BaseUserManager]:
if not email:
raise ValueError(lazy('Please, input email address'))
email = self.normalize_email(email)
user = self.model(email=email, **kwargs)
user.set_password(password)
user.save()
return user
class UpdatedUser(AbstractUser):
""" Переопределенный класс юзера, для авторизации по паре email/password, вместо логина. """
username = None
email = models.EmailField(lazy('email address'), unique=True)
name = models.TextField()
USERNAME_FIELD: str = 'email'
REQUIRED_FIELDS: List[Any] = []
objects = CustomUserManager()
def __str__(self) -> str:
return self.email
class ExamDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Exam
extra_context = {
'title': lazy("Delete Exam")
}
def get_success_url(self):
return '/teacher/user/' + str(self.request.user)
def test_func(self):
exam = self.get_object()
if self.request.user == exam.teacher:
return True
return False
class QuestionDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Question
extra_context = {
'title': lazy("Delete Question")
}
def get_success_url(self):
return '/teacher/exam/update-questions/'
def test_func(self):
question = self.get_object()
if self.request.user == question.exam.teacher:
return True
return False
def validate(self, attrs):
email = attrs.get('email')
password = attrs.get('password')
if email and password:
user = authenticate(email=email, password=password)
if user:
if not user.is_active:
msg = lazy("This account has been disabled")
raise serializers.ValidationError(msg,
code='authorization')
else:
msg = lazy("Unable to log in with the provided credentials.")
raise serializers.ValidationError(msg, code="authorization")
else:
msg = lazy('Cannot authorize with "username" and "password".')
raise serializers.ValidationError(msg, code='authorization')
attrs['user'] = user
return attrs
class Blog(models.Model):
"""博客列表页里一篇博客的数据模型"""
title = models.CharField(max_length=30,
unique=True,
verbose_name=lazy('标题'),
help_text='博客的标题')
author = models.ForeignKey(User, verbose_name=lazy('作者'))
slug = models.SlugField(max_length=50,
unique=True,
verbose_name=lazy('URL'))
body = models.TextField(verbose_name=lazy('正文'))
posted = models.DateField(db_index=True, auto_now_add=True)
class Meta:
verbose_name = lazy('博客')
verbose_name_plural = lazy('博客')
ordering = ['-posted']
def __str__(self):
return '%s' % (self.title)
def get_absolute_url(self):
return reverse('blog:blog_detail', kwargs={'my_args': self.id})
class User(AbstractUser):
"""
Переопределенная модель юзера.
"""
username = models.CharField(max_length=20, unique=True)
email = models.EmailField(lazy('email address'), unique=True)
updated_at = models.DateTimeField(auto_now=True)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
objects = UserManager()
def __str__(self) -> str:
return self.username
def create_questions(request):
if 'last_question_number' not in request.session:
request.session['last_question_number'] = 1
translations = {
'remove_question': _('Remove Question'),
'question': _('Question'),
'questions_degrees_do_not_match_full_mark': _('questions total degrees must equal exam full degree!'),
}
if 'exam_number_of_questions' not in request.session:
request.session['exam_number_of_questions'] = 0
exam_question_count = {
'count': request.session['exam_number_of_questions']
}
exam = Exam.objects.get(id=request.session['exam_id'])
if request.method == 'POST':
# form = CreateExamQuestions(request.POST, instance=request.user)
formset = QuestionFormset(data=request.POST)
if formset.is_valid():
new_formset = formset.save(commit=False)
for form in new_formset:
form.exam_id = request.session['exam_id']
form.question_number = request.session['last_question_number']
request.session['last_question_number'] = request.session['last_question_number'] + 1
form.save()
messages.success(request, _('Your Exam Questions has been created Successfully!'))
return redirect('teacher-exams', request.user)
else:
new_formset = formset.save(commit=False)
for form in new_formset:
print(form.errors, "\n")
else:
# form = CreateExamQuestions()
formset = QuestionFormset(queryset=Question.objects.none())
context = {
'title': lazy('Create Exam Questions'),
'form': formset,
'translations': translations,
'exam_question_count': exam_question_count,
'exam_full_mark':exam.exam_full_mark,
}
request.session['last_question_number'] = 1
return render(request, 'teacher/createQuestions.html', context)
i += 1
if close_tag > -1 and (open_tag == -1 or close_tag < open_tag):
attr = True
return TranslateNodeWrapper(original_do_translate(parser, token),
attr=attr)
#
# MONKEY PATCH translation system
# Als vertaling _EMPTY_ bevat, dan wordt de vertaal-string getoond
#
original_gettext = translation.gettext
def my_gettext(message):
translated = original_gettext(message)
if translated in ['_NO_TRANS_', '_NO_TEXT_']:
return ''
if translated == '_EMPTY_':
url = "%s?locale=nl_NL&q=%s" % (reverse('djinn_i18n_search'), message)
translated = '<b>TO BE TRANSLATED:</b> <a href="%s">"%s"</a>' % (
url,
message
)
return translated
translation.gettext = my_gettext
translation.gettext_lazy = translation.ugettext_lazy = translation.lazy(my_gettext, str)
cursor.close()
#: These models are required to be shared by the system.
REQUIRED_SHARED_MODELS = [
'auth.user',
'auth.permission',
'auth.group',
'boardinghouse.schema',
'sites.site',
'sessions.session',
'contenttypes.contenttype',
'admin.logentry',
'migrations.migration',
# In the case these are not the default values.
lazy(lambda: settings.BOARDINGHOUSE_SCHEMA_MODEL.lower())(),
lazy(lambda: settings.AUTH_USER_MODEL.lower())(),
]
REQUIRED_SHARED_TABLES = [
'django_migrations',
]
def _is_join_model(model):
"""
We define a join model to be one that has no fields that are
not related fields (excluding the primary key), and that has
more than one field.
This may be a satisfactory definition, as a through model,
class QuestionListView(ListView):
model = Question
template_name = "teacher/question_list.html"
extra_context = {"title": lazy("Questions List")}
def QuestionUpdateView(request):
translations = {
'remove_question': _('Remove Question'),
'question': _('Question'),
'questions_degrees_do_not_match_full_mark':_('questions total degrees must equal exam full degree!'),
}
exam_question_count = {
# 'count': Question.objects.filter(exam_id=request.session['updated_exam_id']).count()
'count': request.session['exam_number_of_questions']
}
print(exam_question_count['count'])
exam = Exam.objects.get(id=request.session['updated_exam_id'])
question_number = 1
questions_set = Question.objects.filter(exam_id=exam.id)
for question in questions_set:
question.question_number = question_number
question_number = question_number + 1
question.save()
if request.method == 'POST':
print("here now")
formset = UpdateQuestionFormSet(request.POST, request.FILES, instance=exam)
createQuestionFormset = QuestionFormset(data=request.POST)
context = {
'title': lazy('Update Exam Questions'),
'form': formset,
'createForm':createQuestionFormset,
'translations': translations,
'exam_question_count': exam_question_count,
}
num_questions = request.POST.get('num_questions')
spec_query = Question.objects.filter(exam_id=request.session['updated_exam_id']).order_by('-id')[0]
latest_question_number = spec_query.question_number
question_number = latest_question_number+1
if num_questions is not None and num_questions != 0 and num_questions != "":
if createQuestionFormset.is_valid():
new_formset = createQuestionFormset.save(commit=False)
for form in new_formset:
form.exam_id = request.session['updated_exam_id']
form.question_number = question_number
question_number = question_number+1
form.save()
if formset.is_valid():
new_formset = formset.save(commit=False)
for form in new_formset:
form.save()
messages.success(request, _('Your Exam Questions has been updated Successfully!'))
return redirect('exam-update-questions')
else:
print(
"here in errors else"
)
print(formset.forms)
for form in formset:
print("formset errors")
print(form.errors, "\n")
new_formset = formset.save(commit=False)
else:
formset = UpdateQuestionFormSet(instance=exam)
createQuestionFormset = QuestionFormset(queryset=Question.objects.none())
if exam_question_count['count'] == 0:
request.session['exam_id'] = request.session['updated_exam_id']
messages.error(request, _('Your Exam Does not contain any questions! please add at least one!'))
return redirect('create_questions-page')
context = {
'title': lazy('Update Exam Questions'),
'form': formset,
'translations': translations,
'exam_question_count': exam_question_count,
'createForm': createQuestionFormset,
'exam_full_mark':exam.exam_full_mark,
}
return render(request, 'teacher/updateQuestions.html', context)
%(header)s
### Parameters
%(params)s
### Response
%(data)s
%(footer)s
""")
return template % {'header':header, 'params':params, 'data':data, 'footer':footer}
apidoc_lazy = lazy(_apidoc_lazy, six.text_type)
def _combine_string(string, args=None):
"""
Combines a template string with the passed arguments
"""
if args is None:
return string
return string % args
string_lazy = lazy(_combine_string, six.text_type)
JS_BOOLEAN_TEMPLATE = """
```
#!javascript
def teacherExamListView(request,username):
from datetime import date
if 'teacher_searched' not in request.session:
request.session['teacher_searched'] = False
today = date.today()
user = get_object_or_404(User, username=username)
queryset = Exam.objects.filter(teacher=user).order_by('-exam_date')
for record in queryset:
if today > record.exam_date:
record.exam_status = 'Expired'
elif today < record.exam_date or today == record.exam_date:
record.exam_status = 'Active'
record.save()
user = get_object_or_404(User, username=username)
# handle questions numbers
examSet = Exam.objects.filter(teacher=user).order_by('-exam_date')
queryset = Exam.objects.filter(teacher=user).order_by('-exam_date')
for exam in queryset:
questions = Question.objects.filter(exam_id=exam.id).count()
exam.exam_number_of_questions = questions
exam.save()
context = {
'title': lazy("All teacher's exams"),
}
if request.method == 'POST' or request.session['teacher_searched']:
for exam in examSet:
question_number = 1
questions_set = Question.objects.filter(exam_id=exam.id)
for question in questions_set:
question.question_number = question_number
question_number = question_number + 1
question.save()
print('here i am')
basic_search_btn = request.POST.get('base_search')
advanced_search_btn = request.POST.get('advanced_search')
print('basic search',basic_search_btn)
print('advanced search',advanced_search_btn)
if basic_search_btn != None:
request.session['advanced_search'] = False
context['search_bar'] = True
search_phrase = request.POST.get('search_phrase')
search_option = request.POST.get('search_option')
filters = {'exam_name': search_phrase}
if search_phrase != '' and search_phrase != None and search_phrase != 'Search Phrase' and search_phrase != 'عبارة البحث':
if search_option != 'none' and search_option != None:
if search_option == 'examName':
queryset = Exam.objects.filter(teacher=user, exam_name=search_phrase)
filters['exam_name'] = search_phrase
filters.pop('exam_unique_identifier', None)
else:
print("Iam here now baby")
queryset = Exam.objects.filter(teacher=user, exam_unique_identifier=search_phrase)
filters['exam_unique_identifier'] = search_phrase
filters.pop('exam_name', None)
else:
queryset = Exam.objects.filter(teacher=user, exam_name=search_phrase)
if not queryset.exists():
messages.error(request,_("Sorry we didn't found any match for your search! Please Try another one!"))
queryset = Exam.objects.filter(teacher=user).order_by('-exam_date')
else:
request.session['basic_search'] = filters
elif advanced_search_btn != None:
request.session['basic_search'] = False
context['search_bar'] = True
exam_name = request.POST.get('exam_name')
exam_unique_identifier = request.POST.get('unique_identifier')
exam_status = request.POST.get('exam_status')
order_by = request.POST.get('order_by')
filters = {}
if exam_name != None and exam_name != '':
filters['exam_name'] = exam_name
if exam_unique_identifier != None and exam_unique_identifier != '':
filters['exam_unique_identifier'] = exam_unique_identifier
if exam_status != None and exam_status != '' and exam_status != 'none' :
print(exam_status)
filters['exam_status'] = exam_status
if order_by != None and order_by != '' and order_by != 'none':
print(order_by)
print(order_by)
if order_by == '-exam_date':
queryset = Exam.objects.filter(**filters).order_by('-exam_date')
else:
queryset = Exam.objects.filter(**filters).order_by('exam_date')
else:
queryset = Exam.objects.filter(**filters)
if not queryset.exists():
context['exams'] = 'none'
messages.error(request, _('There is no exam matching your search!! Please Try again!'))
else:
request.session['advanced_search'] = filters
if not queryset.exists():
context['exams'] = 'none'
messages.error(request, _('There is no exam matching your search!! Please Try again!'))
else:
print('before last else')
print('base_search',basic_search_btn)
print('advanced_search',advanced_search_btn)
if request.POST.get('base_search') != None or request.POST.get('advanced_search') != None:
request.session['teacher_searched'] = True
if 'basic_search' in request.session:
if request.session['basic_search'] != False:
filters = request.session['basic_search']
queryset = Exam.objects.filter(teacher=user,**filters)
paginator = Paginator(queryset, 5)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
if 'advanced_search' in request.session:
if request.session['advanced_search'] != False:
filters = request.session['advanced_search']
queryset = Exam.objects.filter(teacher=user,**filters)
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
else:
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
return render(request,'teacher/teacher_exams.html',context)
else:
print('here i am in get')
user = get_object_or_404(User, username=username)
queryset = Exam.objects.filter(teacher=user).order_by('-exam_date')
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
return render(request, 'teacher/teacher_exams.html', context)
def department(request):
if request.method == "GET":
if request.GET.get("name") != None:
department = Department.objects.get(id=request.GET.get("name"))
context = {
"employees":
Employee.objects.filter(department=department.id),
"employees_count":
len(Employee.objects.filter(department=department.id)),
"productions":
Production.objects.filter(department=department.id),
"productions_count":
len(Production.objects.filter(department=department.id))
}
return render(request, "account/department.html", context)
elif request.GET.get("edit") != None:
department = Department.objects.get(id=request.GET.get("edit"))
form = DepartmentForm(instance=department)
context = {"department": department, "form": form}
return render(request, "account/department_edit.html", context)
elif request.GET.get("add") != None:
form = DepartmentForm()
context = {"form": form}
return render(request, "account/department_edit.html", context)
elif request.GET.get("delete") != None:
department = Department.objects.get(id=request.GET.get("delete"))
if Department.objects.filter(father=department.id):
messages.error(request, lazy("当前部门仍然有下属机构, 删除阻止"))
return HttpResponseRedirect(reverse("department"))
else:
Department.objects.filter(
id=request.GET.get("delete")).delete()
return HttpResponseRedirect(reverse("department"))
else:
departments = Department.objects.all()
for department in departments:
department.employees_count = len(
Employee.objects.filter(department=department.id))
context = {"departments": departments}
return render(request, "account/departments_list.html", context)
elif request.method == "POST":
if request.GET.get("edit") != None:
department = Department.objects.get(id=request.GET.get("edit"))
form = DepartmentForm(data=request.POST, instance=department)
context = {"department": department, "form": form}
if form.is_valid():
# =====================================================================================================
# this is a checking part for providing a unique department full name
# =====================================================================================================
try:
check = Department.objects.get(
full_name=form.cleaned_data["full_name"])
except:
check = None
if not check or int(check.id) == int(request.GET.get("edit")):
form.save()
return HttpResponseRedirect(reverse("department"))
else:
context["warn_msg"] = "该部门已经存在, 请勿重复建立"
return render(request, "account/department_edit.html",
context)
# =====================================================================================================
else:
return render(request, "account/department_edit.html", context)
elif request.GET.get("add") != None:
form = DepartmentForm(request.POST)
context = {"form": form}
if form.is_valid():
# =====================================================================================================
# this is a checking part too
# =====================================================================================================
try:
check = Department.objects.get(
full_name=form.cleaned_data["full_name"])
except:
check = None
if not check:
form.save()
return HttpResponseRedirect(reverse("department"))
else:
context["warn_msg"] = "该部门已经存在, 请勿重复建立"
return render(request, "account/department_edit.html",
context)
# =====================================================================================================
else:
return render(request, "account/department_edit.html", context)
else:
return HttpResponseBadRequest(
content="POST 错误 *** 错误定位到 account.views.department")
else:
return HttpResponseBadRequest(
content="request 错误 *** 错误定位到 account.views.department")
from django import forms
from django.contrib.auth import password_validation
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.utils.translation import lazy, gettext
gettext_lazy = ugettext_lazy = lazy(gettext, str)
class SignUpForm(UserCreationForm):
username = forms.CharField(
max_length=20,
required=True,
widget=forms.TextInput(attrs={'class': 'form-control'}))
first_name = forms.CharField(
max_length=30,
required=False,
help_text='Optional.',
widget=forms.TextInput(attrs={'class': 'form-control'}))
last_name = forms.CharField(
max_length=30,
required=False,
help_text='Optional.',
widget=forms.TextInput(attrs={'class': 'form-control'}))
email = forms.EmailField(
max_length=254,
help_text='Required. Inform a valid email address.',
widget=forms.TextInput(attrs={'class': 'form-control'}))
password1 = forms.CharField(
label=gettext_lazy("Password"),
strip=False,
class ExamDetailView(DetailView):
model = Exam
extra_context = {
'title': lazy("Exam Details")
}
remove_class, get_subelements, ET
from tailoring2.basetype import Basetype, IntBasetype, DatetimeBasetype,\
StringBasetype, DecimalBasetype
from tailoring2.authorutil import isEmpty
from tailoring2.textutil import parwrap, conjunctionize, conjunctionize_list
try:
# attempt to bring in the django translation subsystem, if it's available.
from django.utils.translation import string_concat, lazy, ugettext_lazy as _
except ImportError:
# it appears that it isn't, so let's stub it out for now
string_concat = lambda *strings: u''.join(unicode(s) for s in strings)
_ = lambda s: unicode(s)
lazy = lambda func, *resultclasses: func
lazy_format = lazy(lambda a, b: operator.mod(a, b), unicode)
try:
next
except NameError:
# Python 2.6+ has 'next()', earlier versions do not
class __NoDefault(object): pass
_NoDefault = __NoDefault()
def next(iterator, default=_NoDefault):
try:
return iterator.next()
except StopIteration:
if default is not _NoDefault:
return default
raise
cursor.close()
#: These models are required to be shared by the system.
REQUIRED_SHARED_MODELS = [
'auth.user',
'auth.permission',
'auth.group',
'boardinghouse.schema',
'sites.site',
'sessions.session',
'contenttypes.contenttype',
'admin.logentry',
'migrations.migration',
# In the case these are not the default values.
lazy(lambda: settings.BOARDINGHOUSE_SCHEMA_MODEL.lower())(),
lazy(lambda: settings.AUTH_USER_MODEL.lower())(),
]
REQUIRED_SHARED_TABLES = [
'django_migrations',
]
def _is_join_model(model):
"""
We define a join model to be one that has no fields that are
not related fields (excluding the primary key), and that has
more than one field.
This may be a satisfactory definition, as a through model,
class AllExamsListView(ListView):
model = Exam
template_name = 'student/search_exams.html' # <app>/<model>_<viewtype>.html
context_object_name = 'exams'
paginate_by = 5
extra_context = {'title': lazy("All Exams"), 'update': True}
def get_queryset(self):
from datetime import date
today = date.today()
basic_search_btn = self.request.GET.get('base_search')
advanced_search_btn = self.request.GET.get('advanced_search')
querySet = Exam.objects.all()
for record in querySet:
if today > record.exam_date:
record.exam_status = 'Expired'
elif today < record.exam_date or today == record.exam_date:
record.exam_status = 'Active'
record.save()
querySet = Exam.objects.filter(exam_status='Active')
if basic_search_btn != None:
search_phrase = self.request.GET.get('search_phrase')
search_option = self.request.GET.get('search_option')
if search_phrase != '' and search_phrase != None and search_phrase != 'Search Phrase' and search_phrase != 'عبارة البحث':
if search_option != 'none' and search_option != None:
if search_option == 'examName':
querySet = Exam.objects.filter(exam_name=search_phrase,
exam_status='Active')
elif search_option == 'examUniqueIdentifier':
querySet = Exam.objects.filter(
exam_unique_identifier=search_phrase,
exam_status='Active')
else:
querySet = Exam.objects.filter(
exam_unique_identifier=search_phrase,
exam_status='Active')
else:
querySet = Exam.objects.filter(exam_name=search_phrase,
exam_status='Active')
if not querySet.exists():
messages.error(
self.request,
_("Sorry we didn't found any match for your search! Please Try another one!"
))
querySet = Exam.objects.all().order_by('-exam_date')
elif advanced_search_btn != None:
print('advanced search btn')
teacher_username = self.request.GET.get('teacher_name')
exam_name = self.request.GET.get('exam_name')
exam_unique_identifier = self.request.GET.get('unique_identifier')
exam_status = self.request.GET.get('exam_status')
order_by = self.request.GET.get('order_by')
filters = {'exam_status': 'Active'}
if teacher_username != None and teacher_username != '' and teacher_username != 'none':
print(teacher_username)
user = User.objects.get(username=teacher_username)
filters['teacher_id'] = user.id
if exam_name != None and exam_name != '':
print('exam name')
print(exam_name)
filters['exam_name'] = exam_name
if exam_unique_identifier != None and exam_unique_identifier != '':
filters['exam_unique_identifier'] = exam_unique_identifier
if exam_status != None and exam_status != '' and exam_status != 'none':
filters['exam_status'] = exam_status
if order_by != None and order_by != '' and order_by != 'none':
print(order_by)
if order_by == '-exam_date':
querySet = Exam.objects.filter(
**filters).order_by('-exam_date')
else:
querySet = Exam.objects.filter(
**filters).order_by('exam_date')
else:
querySet = Exam.objects.filter(**filters)
return querySet
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super().get_context_data(**kwargs)
# Add in a QuerySet of all the books
# user = get_object_or_404(User, username=self.kwargs.get('username'))
exam_query = Exam.objects.all()
teacher_names = User.objects.filter(is_teacher=1)
encryptedIds = list()
context['teacher_names'] = teacher_names
querySet = self.get_queryset()
if not querySet.exists():
context['exams'] = 'none'
context['examIDs'] = 'none'
messages.error(
self.request,
_('There is no exam matching your search!! Please Try again!'))
if not exam_query.exists():
context['exams'] = 'none'
context['examIDs'] = 'none'
messages.error(
self.request,
_('There is no exam created yet!! Please Try again later!'))
return context
class ClonableModelAdmin(ModelAdmin):
clone_verbose_name = lazy('Clone')
change_form_template = 'modelclone/change_form.html'
def clone_link(self, clonable_model):
'''
Method to be used on `list_display`, renders a link to clone model
'''
_url = reverse('admin:{0}_{1}_clone'.format(
clonable_model._meta.app_label,
getattr(clonable_model._meta, 'module_name',
getattr(clonable_model._meta, 'model_name', ''))),
args=(clonable_model._get_pk_val(), ),
current_app=self.admin_site.name)
return '<a href="{0}">{1}</a>'.format(_url, self.clone_verbose_name)
clone_link.short_description = clone_verbose_name # not overridable by subclass
clone_link.allow_tags = True
def get_urls(self):
url_name = '{0}_{1}_clone'.format(
self.model._meta.app_label,
getattr(self.model._meta, 'module_name',
getattr(self.model._meta, 'model_name', '')))
if VERSION[0] == 1 and VERSION[1] < 9:
from django.conf.urls import patterns
new_urlpatterns = patterns(
'',
url(r'^(.+)/clone/$',
self.admin_site.admin_view(self.clone_view),
name=url_name))
elif VERSION[0] > 1 or (VERSION[0] == 1 and VERSION[1] >= 9):
new_urlpatterns = [
url(r'^(.+)/change/clone/$',
self.admin_site.admin_view(self.clone_view),
name=url_name)
]
original_urlpatterns = super(ClonableModelAdmin, self).get_urls()
return new_urlpatterns + original_urlpatterns
def change_view(self, request, object_id, form_url='', extra_context=None):
extra_context = extra_context or {}
extra_context.update({
'clone_verbose_name': self.clone_verbose_name,
'include_clone_link': True,
})
return super(ClonableModelAdmin,
self).change_view(request, object_id, form_url,
extra_context)
def clone_view(self, request, object_id, form_url='', extra_context=None):
opts = self.model._meta
if not self.has_add_permission(request):
raise PermissionDenied
original_obj = self.get_object(request, unquote(object_id))
if original_obj is None:
raise Http404(
_('{name} object with primary key {key} does not exist.'.
format(name=force_text(opts.verbose_name),
key=repr(escape(object_id)))))
ModelForm = self.get_form(request)
formsets = []
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
new_object = self.save_form(request, form, change=False)
form_validated = True
else:
new_object = self.model()
form_validated = False
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(
data=request.POST,
files=request.FILES,
instance=new_object,
save_as_new="_saveasnew" in request.POST, # ????
prefix=prefix)
formsets.append(formset)
if all_valid(formsets) and form_validated:
# if original model has any file field, save new model
# with same paths to these files
for name in vars(original_obj):
field = getattr(original_obj, name)
if isinstance(field,
FieldFile) and name not in request.FILES:
setattr(new_object, name, field)
self.save_model(request, new_object, form, False)
self.save_related(request, form, formsets, False)
try:
self.log_addition(request, new_object)
except TypeError:
# In Django 1.9 we need one more param
self.log_addition(request, new_object, "Cloned object")
return self.response_add(request, new_object, None)
else:
initial = model_to_dict(original_obj)
initial = self.tweak_cloned_fields(initial)
form = ModelForm(initial=initial)
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
initial = []
queryset = inline.get_queryset(request).filter(
**{FormSet.fk.name: original_obj})
for obj in queryset:
initial.append(
model_to_dict(
obj, exclude=[obj._meta.pk.name, FormSet.fk.name]))
initial = self.tweak_cloned_inline_fields(prefix, initial)
formset = FormSet(prefix=prefix, initial=initial)
# Since there is no way to customize the `extra` in the constructor,
# construct the forms again...
# most of this view is a hack, but this is the ugliest one
formset.extra = len(initial) + formset.extra
# _construct_forms() was removed on django 1.6
# see https://github.com/django/django/commit/ef79582e8630cb3c119caed52130c9671188addd
if hasattr(formset, '_construct_forms'):
formset._construct_forms()
formsets.append(formset)
admin_form = helpers.AdminForm(form,
list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
media = self.media + admin_form.media
inline_admin_formsets = []
for inline, formset in zip(self.get_inline_instances(request),
formsets):
fieldsets = list(inline.get_fieldsets(request, original_obj))
readonly = list(inline.get_readonly_fields(request, original_obj))
prepopulated = dict(
inline.get_prepopulated_fields(request, original_obj))
inline_admin_formset = InlineAdminFormSetFakeOriginal(
inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
title = u'{0} {1}'.format(self.clone_verbose_name, opts.verbose_name)
context = {
'title': title,
'original': title,
'adminform': admin_form,
'is_popup': "_popup" in getattr(request, 'REQUEST', request.GET),
'show_delete': False,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
change=False)
def tweak_cloned_fields(self, fields):
"""Override this method to tweak a cloned object before displaying its form.
``fields`` is a dictionary containing the cloned object's field data (the result of
``model_to_dict()``).
It does *not* contain inline fields. To tweak inline fields, override
``tweak_cloned_inline_fields()``.
This method returns the modified ``fields``.
"""
return fields
def tweak_cloned_inline_fields(self, related_name, fields_list):
"""Override this method to tweak a cloned inline before displaying its form.
``related_name`` is the name of the relation being inlined. Note that if you've inline the
same relation more than once, ``related_name`` will have a numerical suffix, for example,
``comment_set-2``.
``fields_list`` is a list of dictionaries containing the inline field data (the result of
``model_to_dict()`` for each inlined row).
This method returns the modified ``fields_list``.
"""
return fields_list
from .models import Exam, Question
from django import forms
from django.utils.translation import gettext_lazy as lazy
from django.utils.translation import gettext as _
from django.forms import ModelForm
from ckeditor.widgets import CKEditorWidget
from django.forms import modelformset_factory,inlineformset_factory
TIME_LENGTH = (
(lazy('10 minutes'),'10 minutes'),
(lazy('15 minutes'), '15 minutes'),
(lazy('30 minutes'), '30 minutes'),
(lazy('1 hour'), '1 hour'),
(lazy('1:30 hour'), '1:30 hour'),
(lazy('2 hours'),'2 hours'),
)
class CreateExamQuestions(ModelForm):
class Meta:
model = Question
fields = [
'question_text',
'question_optimal_answer',
'question_degree',
]
exclude = ["exam"]
labels = {
'question_text': _('question text'),
'question_optimal_answer': _('question optimal answer'),
'question_degree': _('question degree')
def all_exams_listview(request):
from datetime import date
if 'student_searched' not in request.session:
request.session['student_searched'] = False
today = date.today()
# user = get_object_or_404(User, username=username)
queryset = Exam.objects.filter(exam_status='Active')
for record in queryset:
if today > record.exam_date:
record.exam_status = 'Expired'
elif today < record.exam_date or today == record.exam_date:
record.exam_status = 'Active'
record.save()
context = {
'title': lazy("All exams"),
}
"""
get all teachers that have created exams
"""
teachers = Exam.objects.select_related('teacher').values(
'teacher_id').distinct()
empty = User.objects.none()
for teacher in teachers:
t = User.objects.filter(id=teacher['teacher_id'])
empty |= t
context['teacher_names'] = empty
if request.method == 'POST' or request.session['student_searched']:
print('here i am')
basic_search_btn = request.POST.get('base_search')
advanced_search_btn = request.POST.get('advanced_search')
print('basic search', basic_search_btn)
print('advanced search', advanced_search_btn)
if basic_search_btn is not None:
request.session['advanced_search'] = False
context['search_bar'] = True
search_phrase = request.POST.get('search_phrase')
search_option = request.POST.get('search_option')
filters = {'exam_status': 'Active'}
if search_phrase != '' and search_phrase is not None and search_phrase != 'Search Phrase' \
and search_phrase != 'عبارة البحث':
if search_option != 'none' and search_option is not None:
if search_option == 'examName':
queryset = Exam.objects.filter(exam_name=search_phrase,
exam_status='Active')
filters['exam_name'] = search_phrase
else:
queryset = Exam.objects.filter(
exam_unique_identifier=search_phrase,
exam_status='Active')
filters['exam_unique_identifier'] = search_phrase
else:
queryset = Exam.objects.filter(exam_name=search_phrase,
exam_status='Active')
if not queryset.exists():
messages.error(
request,
_("Sorry we didn't found any match for your search! Please Try another one!"
))
queryset = Exam.objects.filter(
exam_status='Active').order_by('-exam_date')
else:
request.session['basic_search'] = filters
elif advanced_search_btn is not None:
request.session['basic_search'] = False
context['search_bar'] = True
exam_name = request.POST.get('exam_name')
exam_unique_identifier = request.POST.get('unique_identifier')
exam_status = request.POST.get('exam_status')
teacher_name = request.POST.get('teacher_name')
order_by = request.POST.get('order_by')
filters = {'exam_status': 'Active'}
if teacher_name is not None and teacher_name != '' and teacher_name != 'none':
filters['teacher_id'] = teacher_name
if exam_name is not None and exam_name != '':
filters['exam_name'] = exam_name
if exam_unique_identifier is not None and exam_unique_identifier != '':
filters['exam_unique_identifier'] = exam_unique_identifier
if exam_status is not None and exam_status != '' and exam_status != 'none':
print(exam_status)
filters['exam_status'] = exam_status
if order_by is not None and order_by != '' and order_by != 'none':
print(order_by)
print(order_by)
if order_by == '-exam_date':
queryset = Exam.objects.filter(
**filters).order_by('-exam_date')
else:
queryset = Exam.objects.filter(
**filters).order_by('exam_date')
else:
queryset = Exam.objects.filter(**filters)
if not queryset.exists():
context['exams'] = 'none'
messages.error(
request,
_('There is no exam matching your search!! Please Try again!'
))
else:
request.session['advanced_search'] = filters
if not queryset.exists():
context['exams'] = 'none'
messages.error(
request,
_('There is no exam matching your search!! Please Try again!'))
else:
if request.POST.get('base_search') is not None or request.POST.get(
'advanced_search') is not None:
request.session['student_searched'] = True
if 'basic_search' in request.session:
if request.session['basic_search']:
filters = request.session['basic_search']
queryset = Exam.objects.filter(**filters)
paginator = Paginator(queryset, 5)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
if 'advanced_search' in request.session:
if request.session['advanced_search']:
filters = request.session['advanced_search']
queryset = Exam.objects.filter(**filters)
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
else:
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
return render(request, 'student/search_exams.html', context)
else:
queryset = Exam.objects.filter(
exam_status='Active').order_by('-exam_date')
paginator = Paginator(queryset, 6)
page = request.GET.get('page')
context['page_obj'] = paginator.get_page(page)
context['exams'] = paginator.get_page(page)
context['is_paginated'] = True
return render(request, 'student/search_exams.html', context)
class Meta:
verbose_name = lazy('博客')
verbose_name_plural = lazy('博客')
ordering = ['-posted']
