def index(request):
user = request.user
show_delegated = get_parameter_from_url_or_session(request, "show_delegated", True)
contributor_visible_states = ['prepared', 'editor_approved', 'approved', 'in_evaluation', 'evaluated', 'reviewed', 'published']
own_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states) & (
Q(responsibles=user) |
Q(evaluations__contributions__contributor=user)
)
)
own_evaluations = [evaluation for course in own_courses for evaluation in course.evaluations.all() if evaluation.can_be_seen_by(user)]
for evaluation in own_evaluations:
evaluation.contributes_to = evaluation.contributions.filter(contributor=user).exists()
displayed_evaluations = set(own_evaluations)
if show_delegated:
represented_users = user.represented_users.all()
delegated_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states) & (
Q(responsibles__in=represented_users) |
Q(
evaluations__contributions__role=Contribution.Role.EDITOR,
evaluations__contributions__contributor__in=represented_users,
)
)
)
delegated_evaluations = set(evaluation for course in delegated_courses for evaluation in course.evaluations.all() if evaluation.can_be_seen_by(user))
for evaluation in delegated_evaluations:
evaluation.delegated_evaluation = True
displayed_evaluations |= delegated_evaluations - displayed_evaluations
displayed_evaluations = list(displayed_evaluations)
displayed_evaluations.sort(key=lambda evaluation: (evaluation.course.name, evaluation.name)) # evaluations must be sorted for regrouping them in the template
for evaluation in displayed_evaluations:
if evaluation.state == "published":
if not evaluation.is_single_result:
evaluation.distribution = calculate_average_distribution(evaluation)
else:
evaluation.single_result_rating_result = get_single_result_rating_result(evaluation)
evaluation.distribution = normalized_distribution(evaluation.single_result_rating_result.counts)
evaluation.avg_grade = distribution_to_grade(evaluation.distribution)
displayed_evaluations = get_evaluations_with_course_result_attributes(displayed_evaluations)
semesters = Semester.objects.all()
semester_list = [dict(
semester_name=semester.name,
id=semester.id,
is_active=semester.is_active,
evaluations=[evaluation for evaluation in displayed_evaluations if evaluation.course.semester_id == semester.id]
) for semester in semesters]
template_data = dict(
semester_list=semester_list,
show_delegated=show_delegated,
delegate_selection_form=DelegateSelectionForm(),
)
return render(request, "contributor_index.html", template_data)
def index(request):
user = request.user
show_delegated = get_parameter_from_url_or_session(request, "show_delegated", True)
contributor_visible_states = ['prepared', 'editor_approved', 'approved', 'in_evaluation', 'evaluated', 'reviewed', 'published']
own_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states) & (
Q(responsibles=user) |
Q(evaluations__contributions__contributor=user)
)
)
own_evaluations = [evaluation for course in own_courses for evaluation in course.evaluations.all() if evaluation.can_be_seen_by(user)]
for evaluation in own_evaluations:
evaluation.contributes_to = evaluation.contributions.filter(contributor=user).exists()
displayed_evaluations = set(own_evaluations)
if show_delegated:
represented_users = user.represented_users.all()
delegated_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states) & (
Q(responsibles__in=represented_users) |
Q(evaluations__contributions__can_edit=True, evaluations__contributions__contributor__in=represented_users)
)
)
delegated_evaluations = set(evaluation for course in delegated_courses for evaluation in course.evaluations.all() if evaluation.can_be_seen_by(user))
for evaluation in delegated_evaluations:
evaluation.delegated_evaluation = True
displayed_evaluations |= delegated_evaluations - displayed_evaluations
displayed_evaluations = list(displayed_evaluations)
displayed_evaluations.sort(key=lambda evaluation: evaluation.full_name) # evaluations must be sorted for regrouping them in the template
for evaluation in displayed_evaluations:
if evaluation.state == "published":
if not evaluation.is_single_result:
evaluation.distribution = calculate_average_distribution(evaluation)
evaluation.avg_grade = distribution_to_grade(evaluation.distribution)
else:
evaluation.single_result_rating_result = get_single_result_rating_result(evaluation)
displayed_evaluations = get_evaluations_with_course_result_attributes(displayed_evaluations)
semesters = Semester.objects.all()
semester_list = [dict(
semester_name=semester.name,
id=semester.id,
is_active_semester=semester.is_active_semester,
evaluations=[evaluation for evaluation in displayed_evaluations if evaluation.course.semester_id == semester.id]
) for semester in semesters]
template_data = dict(
semester_list=semester_list,
show_delegated=show_delegated,
delegate_selection_form=DelegateSelectionForm(),
)
return render(request, "contributor_index.html", template_data)
def index(request):
user = request.user
show_delegated = get_parameter_from_url_or_session(request,
"show_delegated", True)
contributor_visible_states = [
'prepared', 'editor_approved', 'approved', 'in_evaluation',
'evaluated', 'reviewed', 'published'
]
own_evaluations = Evaluation.objects.filter(
contributions__contributor=user, state__in=contributor_visible_states)
displayed_evaluations = list(own_evaluations)
if show_delegated:
represented_users = user.represented_users.all()
delegated_evaluations = Evaluation.objects.exclude(
id__in=own_evaluations).filter(
contributions__can_edit=True,
contributions__contributor__in=represented_users,
state__in=contributor_visible_states)
for evaluation in delegated_evaluations:
evaluation.delegated_evaluation = True
displayed_evaluations += list(delegated_evaluations)
displayed_evaluations.sort(key=lambda evaluation: list(STATES_ORDERED.keys(
)).index(evaluation.state))
delegate_selection_form = DelegateSelectionForm()
for evaluation in displayed_evaluations:
evaluation.distribution = calculate_average_distribution(evaluation)
evaluation.avg_grade = distribution_to_grade(evaluation.distribution)
semesters = Semester.objects.all()
semester_list = [
dict(semester_name=semester.name,
id=semester.id,
is_active_semester=semester.is_active_semester,
evaluations=[
evaluation for evaluation in displayed_evaluations
if evaluation.course.semester_id == semester.id
]) for semester in semesters
]
template_data = dict(
semester_list=semester_list,
show_delegated=show_delegated,
delegate_selection_form=delegate_selection_form,
)
return render(request, "contributor_index.html", template_data)
def index(request):
user = request.user
show_delegated = get_parameter_from_url_or_session(request,
"show_delegated", True)
represented_proxy_users = user.represented_users.filter(is_proxy_user=True)
contributor_visible_states = [
Evaluation.State.PREPARED,
Evaluation.State.EDITOR_APPROVED,
Evaluation.State.APPROVED,
Evaluation.State.IN_EVALUATION,
Evaluation.State.EVALUATED,
Evaluation.State.REVIEWED,
Evaluation.State.PUBLISHED,
]
own_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states)
&
(Q(responsibles=user)
| Q(evaluations__contributions__contributor=user)
|
Q(evaluations__contributions__contributor__in=represented_proxy_users)
| Q(responsibles__in=represented_proxy_users)))
own_evaluations = (Evaluation.objects.filter(
course__in=own_courses).annotate(contributes_to=Exists(
Evaluation.objects.filter(
id=OuterRef(
"id"), contributions__contributor=user))).prefetch_related(
"course", "course__evaluations", "course__degrees",
"course__type", "course__semester"))
own_evaluations = [
evaluation for evaluation in own_evaluations
if evaluation.can_be_seen_by(user)
]
displayed_evaluations = own_evaluations
if show_delegated:
represented_users = user.represented_users.exclude(is_proxy_user=True)
delegated_courses = Course.objects.filter(
Q(evaluations__state__in=contributor_visible_states)
&
(Q(responsibles__in=represented_users)
| Q(
evaluations__contributions__role=Contribution.Role.EDITOR,
evaluations__contributions__contributor__in=represented_users,
)))
delegated_evaluations = Evaluation.objects.filter(
course__in=delegated_courses).prefetch_related(
"course", "course__evaluations", "course__degrees",
"course__type", "course__semester")
delegated_evaluations = [
evaluation for evaluation in delegated_evaluations
if evaluation.can_be_seen_by(user)
]
for evaluation in delegated_evaluations:
evaluation.delegated_evaluation = True
displayed_evaluations += set(delegated_evaluations) - set(
displayed_evaluations)
displayed_evaluations.sort(
key=lambda evaluation: (evaluation.course.name, evaluation.name)
) # evaluations must be sorted for regrouping them in the template
annotate_distributions_and_grades(e for e in displayed_evaluations
if e.state == Evaluation.State.PUBLISHED)
displayed_evaluations = get_evaluations_with_course_result_attributes(
displayed_evaluations)
semesters = Semester.objects.all()
semester_list = [
dict(
semester_name=semester.name,
id=semester.id,
is_active=semester.is_active,
evaluations=[
evaluation for evaluation in displayed_evaluations
if evaluation.course.semester_id == semester.id
],
) for semester in semesters
]
template_data = dict(
semester_list=semester_list,
show_delegated=show_delegated,
delegate_selection_form=DelegateSelectionForm(),
)
return render(request, "contributor_index.html", template_data)
