def checking_group_users(request, group_name):
group = get_object_or_404(
models.CheckingGroup,
school=request.school,
short_name=group_name,
)
users = [
u.user for u in group.actual_users.select_related('user__profile')
]
tasks = list(group.tasks.order_by('order'))
user_ids = [u.id for u in users]
task_ids = [t.id for t in tasks]
solutions = list(
models.FileEntranceExamTaskSolution.objects.filter(
user_id__in=user_ids,
task_id__in=task_ids,
))
checks = list(
models.CheckedSolution.objects.filter(
solution__user_id__in=user_ids,
solution__task_id__in=task_ids,
).select_related('solution'))
solutions_by_user = group_by(solutions, lambda s: s.user_id)
solved_tasks_count_by_user = {
user_id: len({s.task_id
for s in solutions})
for user_id, solutions in solutions_by_user.items()
}
checks_by_user = group_by(checks, lambda c: c.solution.user_id)
checked_tasks_count_by_user = {
user_id: len({c.solution.task_id
for c in checks})
for user_id, checks in checks_by_user.items()
}
return render(
request, 'entrance/staff/group_users.html', {
'group':
group,
'users':
users,
'tasks':
tasks,
'solutions':
solutions,
'checks':
checks,
'solved_tasks_count_by_user':
collections.defaultdict(int, solved_tasks_count_by_user),
'checked_tasks_count_by_user':
collections.defaultdict(int, checked_tasks_count_by_user),
})
def scans(request):
submitted_form = None
if request.method == 'POST':
submitted_form = forms.EnrolledScanForm(data=request.POST,
files=request.FILES)
if submitted_form.is_valid():
save_scan(request.school, request.user, submitted_form)
all_requirements = (models.EnrolledScanRequirement.objects.filter(
school=request.school))
user_requirements = [
r for r in all_requirements if r.is_needed_for_user(request.user)
]
user_scans = group_by(
models.EnrolledScan.objects.filter(
requirement__school=request.school,
user=request.user,
).order_by('-created_at'), operator.attrgetter('requirement_id'))
for requirement in user_requirements:
if requirement.id in user_scans:
requirement.user_scan = user_scans[requirement.id][0]
else:
requirement.user_scan = None
requirement.form = get_form_for_requirement(requirement,
submitted_form)
return render(request, 'enrolled_scans/scans.html', {
'requirements': user_requirements,
})
def handle(self, *args, **options):
if 'apply_changes' in options:
self._apply_changes = options['apply_changes']
groups = helpers.group_by(models.User.objects.filter(is_active=True).all(),
lambda u: u.email.lower())
for (key, users) in groups.items():
if key == "":
for user in users:
self._process_empty_email_user(user)
elif len(users) <= 1:
pass
else:
self._process_duplicated_emails(users)
self.stdout.write('Need to deactivate %d users...\n' % len(self._to_deactivate_users))
self.stdout.write('Bad staff accounts: %d\n' % len(self._bad_staff_users))
self.stdout.write('Bad accounts: %d\n' % len(self._bad_users))
for user in self._to_deactivate_users:
self._deactivate_user(user)
for user in self._bad_users:
account_info = AccountInfo.build_for_user(user)
self.stdout.write('bad_user:\n%s\n' % str(account_info))
candidates_users = user_models.User.objects.filter(last_name=user.last_name).exclude(id=user.id)
for u in candidates_users:
account_info = AccountInfo.build_for_user(u)
self.stdout.write(str(account_info))
if confirm_action("deactivate %d %s" % (user.id, str(user))):
self._deactivate_user(user)
def get_limit(self, user):
# TODO: check status, if not FINISHED, return self._find_minimal_level()
# It's here to avoid cyclic imports
import modules.topics.models.main as models
user_marks = models.UserMark.objects.filter(user=user, scale_in_topic__topic__questionnaire=self.questionnaire)\
.prefetch_related('scale_in_topic__topic__tags')
requirements = list(
EntranceLevelRequirement.objects.filter(
questionnaire=self.questionnaire).prefetch_related(
'entrance_level'))
requirements_by_tag = group_by(requirements,
operator.attrgetter('tag_id'))
requirements_by_level = group_by(requirements,
operator.attrgetter('entrance_level'))
sum_marks_for_requirements = collections.defaultdict(int)
max_marks_for_requirements = collections.defaultdict(int)
for mark in user_marks:
scale_in_topic = mark.scale_in_topic
topic = scale_in_topic.topic
topic_tags = topic.tags.all()
for tag in topic_tags:
for requirement in requirements_by_tag[tag.id]:
sum_marks_for_requirements[requirement.id] += mark.mark
max_marks_for_requirements[
requirement.id] += scale_in_topic.scale.max_mark
# Если всё плохо, самый просто уровень считаем выполненным — иначе нечего будет решать
maximum_satisfied_level = entrance_models.EntranceLevel.objects.filter(school=self.school)\
.order_by('order').first()
for level, requirements_for_level in requirements_by_level.items():
all_satisfied = True
for requirement in requirements_for_level:
all_satisfied = all_satisfied and requirement.satisfy(
sum_marks_for_requirements[requirement.id],
max_marks_for_requirements[requirement.id])
if all_satisfied:
if level.order > maximum_satisfied_level.order:
maximum_satisfied_level = level
return levels.EntranceLevelLimit(maximum_satisfied_level)
def make_question_variant_orders_unique(apps, schema):
Variant = apps.get_model('questionnaire',
'ChoiceQuestionnaireQuestionVariant')
variants = Variant.objects.prefetch_related('question')
variants_by_question = group_by(variants, operator.attrgetter('question'))
for question_variants in variants_by_question.values():
question_variants.sort(key=operator.attrgetter('order'))
order = 10
for variant in question_variants:
variant.order = order
variant.save()
order += 10
def variant_checked_show_conditions(self):
conditions = (
QuestionnaireBlockVariantCheckedShowCondition.objects.filter(
block__questionnaire=self))
return group_by(conditions, operator.attrgetter('block_id'))
def checking_group_teachers(request, group_name):
checking_group = get_object_or_404(
models.CheckingGroup,
school=request.school,
short_name=group_name,
)
user_ids = list(checking_group.group.user_ids)
tasks = list_to_dict(checking_group.tasks.order_by('order'),
lambda task: task.id, lambda task: task)
task_ids = list(tasks.keys())
checks = models.CheckedSolution.objects.filter(
solution__user_id__in=user_ids,
solution__task_id__in=task_ids,
).select_related('solution', 'checked_by')
checks_grouped_by_teacher = checks.values('checked_by_id')
checks_grouped_by_task_and_teacher = (checks.values(
'solution__task_id', 'checked_by_id'))
teacher_solutions_count = list_to_dict(
checks_grouped_by_teacher.annotate(
count=Count('solution_id', distinct=True)),
operator.itemgetter('checked_by_id'),
operator.itemgetter('count'),
)
teacher_task_solutions_count = list_to_dict(
checks_grouped_by_task_and_teacher.annotate(
count=Count('solution_id', distinct=True)),
operator.itemgetter('checked_by_id'),
operator.itemgetter('solution__task_id'),
operator.itemgetter('count'),
)
average_scores = list_to_dict(
checks_grouped_by_task_and_teacher.annotate(
average_score=sql_round_with_precision(
Cast(Sum('score'), FloatField()) /
Cast(Count('score'), FloatField()), 2)),
operator.itemgetter('checked_by_id'),
operator.itemgetter('solution__task_id'),
operator.itemgetter('average_score'),
)
teacher_tasks = group_by(
checks_grouped_by_task_and_teacher.distinct(),
operator.itemgetter('checked_by_id'),
extract_value_function=operator.itemgetter('solution__task_id'))
teacher_ids = nested_query_list(
checks.order_by('checked_by_id').values_list('checked_by_id',
flat=True).distinct())
teachers = users.models.User.objects.filter(id__in=teacher_ids)
ordered_teachers = sorted(teachers,
key=lambda t: teacher_solutions_count[t.id],
reverse=True)
return render(
request, 'entrance/staff/group_teachers.html', {
'group': checking_group,
'tasks': tasks,
'teachers': ordered_teachers,
'teacher_solutions_count': teacher_solutions_count,
'teacher_tasks': teacher_tasks,
'teacher_task_solutions_count': teacher_task_solutions_count,
'average_scores': average_scores,
})
def check_user(request, user, group=None):
entrance_exam = (models.EntranceExam.objects.filter(
school=request.school).first())
checking_comments = user.entrance_checking_comments.filter(
school=request.school).order_by('created_at')
add_checking_comment_form = forms.AddCheckingCommentForm()
base_entrance_level = None
level_upgrades = []
test_tasks = []
file_tasks = []
program_tasks = []
if entrance_exam is not None:
base_entrance_level = upgrades.get_base_entrance_level(
request.school, user)
level_upgrades = models.EntranceLevelUpgrade.objects.filter(
upgraded_to__school=request.school, user=user)
tasks = upgrades.get_entrance_tasks(request.school, user,
base_entrance_level)
tasks_solutions = group_by(
user.entrance_exam_solutions.filter(
task__exam=entrance_exam).order_by('-created_at'),
operator.attrgetter('task_id'))
for task in tasks:
task.user_solutions = tasks_solutions[task.id]
task.is_solved = task.is_solved_by_user(user)
if type(task) is models.TestEntranceExamTask:
if len(task.user_solutions) > 0:
task.last_try = task.user_solutions[0].solution
task.is_last_correct = task.is_solution_correct(
task.last_try)
else:
task.last_try = None
task.is_last_correct = None
if type(task) is models.FileEntranceExamTask:
if len(task.user_solutions) > 0:
task.last_solution = task.user_solutions[0]
task.checks = list(task.last_solution.checks.all())
else:
task.last_solution = None
task.checks = []
test_tasks = list(
filter(lambda t: type(t) is models.TestEntranceExamTask, tasks))
file_tasks = list(
filter(lambda t: type(t) is models.FileEntranceExamTask, tasks))
program_tasks = list(
filter(lambda t: isinstance(t, models.EjudgeEntranceExamTask),
tasks))
return render(
request, 'entrance/staff/check_user.html', {
'group': group,
'user_for_checking': user,
'base_entrance_level': base_entrance_level,
'level_upgrades': level_upgrades,
'test_tasks': test_tasks,
'file_tasks': file_tasks,
'program_tasks': program_tasks,
'checking_comments': checking_comments,
'add_checking_comment_form': add_checking_comment_form,
'user_summary': UserSummary.summary_for_user(request.school, user),
'clone_accounts': _find_clones(user)
})
def show_conditions(self):
return group_by(
QuestionnaireBlockShowCondition.objects.filter(
block__questionnaire=self), operator.attrgetter('block_id'))
