def get_context_data(self, **kwargs):
context = super(TaskScoresView, self).get_context_data(**kwargs)
monitoring = self.task.organization.monitoring
self.queryform = ParametersQueryForm(self.request.GET)
# These fields should be annotated on paramter for strict pedantic tests.
_param_extra = {'select': {'comment_url': 0, 'score_pk': 0, 'score_table': 0, 'score_openness': 0, 'score_openness_delta': 0}}
# Relevant parameters
relevant_parameters = Parameter.objects.filter(monitoring=monitoring)\
.exclude(exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_rel = Score.objects.filter(task=self.task)\
.exclude(parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
relevant_parameters_exist = relevant_parameters.exists()
# Apply user provided filters to relevant parameters
if self.queryform.is_valid():
relevant_parameters = self.queryform.apply(relevant_parameters)
# Set scores to relevant parameters list
self._set_parameters_scores(relevant_parameters, scores_rel)
self._set_last_comment_url(relevant_parameters, scores_rel)
if self.request.user.is_expert:
# Non relevant parameters
nonrelevant_parameters = Parameter.objects.filter(monitoring=monitoring, exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_nonrel = Score.objects.filter(task=self.task, parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
nonrelevant_parameters_exist = nonrelevant_parameters.exists()
# Apply user provided filters to non relevant parameters
if self.queryform.is_valid():
nonrelevant_parameters = self.queryform.apply(nonrelevant_parameters)
# Set scores to non relevant parameters list
self._set_parameters_scores(nonrelevant_parameters, scores_nonrel)
context.update({
'nonrelevant_parameters': nonrelevant_parameters,
'nonrelevant_parameters_exist': nonrelevant_parameters_exist,
})
# Get questionnaire form
questionnaire_form = None
questions = QQuestion.objects.filter(questionnaire__monitoring=monitoring).order_by("pk")
if questions:
existing_answers = QAnswer.objects.filter(task=self.task).order_by("pk")
initial_data = {"q_%s" % a.question.pk: a.answer(True) for a in existing_answers}
questionnaire_form = QuestionnaireDynForm(questions=questions, initial=initial_data)
context.update({
'relevant_parameters': relevant_parameters,
'relevant_parameters_exist': relevant_parameters_exist,
'mon': monitoring,
'task': self.task,
'questionnaire_form': questionnaire_form,
'invcodeform': SettingsInvCodeForm(),
'orgs_count': Organization.objects.filter(monitoring=monitoring).count(),
'openness': self.task.openness,
'delta': self.task.openness - self.task.openness_initial if self.task.openness is not None else None,
'columns_form': task_scores_columns_form(self.request),
'is_representative': self.request.user.represents(self.task.organization),
})
return context
def get_context_data(self, **kwargs):
context = super(TaskScoresView, self).get_context_data(**kwargs)
monitoring = self.task.organization.monitoring
self.queryform = ParametersQueryForm(self.request.GET)
# These fields should be annotated on paramter for strict pedantic tests.
_param_extra = {
'select': {
'comment_url': 0,
'score_pk': 0,
'score_table': 0,
'score_openness': 0,
'score_openness_delta': 0
}
}
# Relevant parameters
relevant_parameters = Parameter.objects.filter(monitoring=monitoring)\
.exclude(exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_rel = Score.objects.filter(task=self.task)\
.exclude(parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
relevant_parameters_exist = relevant_parameters.exists()
# Apply user provided filters to relevant parameters
if self.queryform.is_valid():
relevant_parameters = self.queryform.apply(relevant_parameters)
# Set scores to relevant parameters list
self._set_parameters_scores(relevant_parameters, scores_rel)
self._set_last_comment_url(relevant_parameters, scores_rel)
if self.request.user.is_expert:
# Non relevant parameters
nonrelevant_parameters = Parameter.objects.filter(monitoring=monitoring, exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_nonrel = Score.objects.filter(task=self.task, parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
nonrelevant_parameters_exist = nonrelevant_parameters.exists()
# Apply user provided filters to non relevant parameters
if self.queryform.is_valid():
nonrelevant_parameters = self.queryform.apply(
nonrelevant_parameters)
# Set scores to non relevant parameters list
self._set_parameters_scores(nonrelevant_parameters, scores_nonrel)
context.update({
'nonrelevant_parameters':
nonrelevant_parameters,
'nonrelevant_parameters_exist':
nonrelevant_parameters_exist,
})
# Get questionnaire form
questionnaire_form = None
questions = QQuestion.objects.filter(
questionnaire__monitoring=monitoring).order_by("pk")
if questions:
existing_answers = QAnswer.objects.filter(
task=self.task).order_by("pk")
initial_data = {
"q_%s" % a.question.pk: a.answer(True)
for a in existing_answers
}
questionnaire_form = QuestionnaireDynForm(questions=questions,
initial=initial_data)
context.update({
'relevant_parameters':
relevant_parameters,
'relevant_parameters_exist':
relevant_parameters_exist,
'mon':
monitoring,
'task':
self.task,
'questionnaire_form':
questionnaire_form,
'invcodeform':
SettingsInvCodeForm(),
'orgs_count':
Organization.objects.filter(monitoring=monitoring).count(),
'openness':
self.task.openness,
'delta':
self.task.openness - self.task.openness_initial
if self.task.openness is not None else None,
'columns_form':
task_scores_columns_form(self.request),
'is_representative':
self.request.user.represents(self.task.organization),
})
return context
class TaskScoresView(TaskScoresMixin, DetailView):
template_name = "scores/task_scores.html"
def post(self, request, *args, **kwargs):
scores_table_columns_form = task_scores_columns_form(request)
if scores_table_columns_form.post_ok(request):
return HttpResponseRedirect(request.path)
else:
return HttpResponseBadRequest()
def get_context_data(self, **kwargs):
context = super(TaskScoresView, self).get_context_data(**kwargs)
monitoring = self.task.organization.monitoring
self.queryform = ParametersQueryForm(self.request.GET)
# These fields should be annotated on paramter for strict pedantic tests.
_param_extra = {'select': {'comment_url': 0, 'score_pk': 0, 'score_table': 0, 'score_openness': 0, 'score_openness_delta': 0}}
# Relevant parameters
relevant_parameters = Parameter.objects.filter(monitoring=monitoring)\
.exclude(exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_rel = Score.objects.filter(task=self.task)\
.exclude(parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
relevant_parameters_exist = relevant_parameters.exists()
# Apply user provided filters to relevant parameters
if self.queryform.is_valid():
relevant_parameters = self.queryform.apply(relevant_parameters)
# Set scores to relevant parameters list
self._set_parameters_scores(relevant_parameters, scores_rel)
self._set_last_comment_url(relevant_parameters, scores_rel)
if self.request.user.is_expert:
# Non relevant parameters
nonrelevant_parameters = Parameter.objects.filter(monitoring=monitoring, exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_nonrel = Score.objects.filter(task=self.task, parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
nonrelevant_parameters_exist = nonrelevant_parameters.exists()
# Apply user provided filters to non relevant parameters
if self.queryform.is_valid():
nonrelevant_parameters = self.queryform.apply(nonrelevant_parameters)
# Set scores to non relevant parameters list
self._set_parameters_scores(nonrelevant_parameters, scores_nonrel)
context.update({
'nonrelevant_parameters': nonrelevant_parameters,
'nonrelevant_parameters_exist': nonrelevant_parameters_exist,
})
# Get questionnaire form
questionnaire_form = None
questions = QQuestion.objects.filter(questionnaire__monitoring=monitoring).order_by("pk")
if questions:
existing_answers = QAnswer.objects.filter(task=self.task).order_by("pk")
initial_data = {"q_%s" % a.question.pk: a.answer(True) for a in existing_answers}
questionnaire_form = QuestionnaireDynForm(questions=questions, initial=initial_data)
context.update({
'relevant_parameters': relevant_parameters,
'relevant_parameters_exist': relevant_parameters_exist,
'mon': monitoring,
'task': self.task,
'questionnaire_form': questionnaire_form,
'invcodeform': SettingsInvCodeForm(),
'orgs_count': Organization.objects.filter(monitoring=monitoring).count(),
'openness': self.task.openness,
'delta': self.task.openness - self.task.openness_initial if self.task.openness is not None else None,
'columns_form': task_scores_columns_form(self.request),
'is_representative': self.request.user.represents(self.task.organization),
})
return context
@staticmethod
def _set_parameters_scores(parameters, scores):
score_fin_dict = {s.parameter.pk: s for s in scores if s.revision == Score.FINAL}
score_int_dict = {s.parameter.pk: s for s in scores if s.revision == Score.INTERIM}
for param in parameters:
score_fin = score_fin_dict.get(param.pk, None)
if score_fin:
param.score_pk = score_fin.pk
param.score_accomplished = score_fin.accomplished
score_int = score_int_dict.get(param.pk, None)
param.score_openness = score_fin.openness
param.score_openness_delta = score_fin.openness - score_int.openness if score_int else 0
criteria = ['found'] + filter(param.__getattribute__, Parameter.OPTIONAL_CRITERIA)
score_table = []
for criterion in ['found'] + Parameter.OPTIONAL_CRITERIA:
if criterion in criteria:
score_table.append({
'score_final': getattr(score_fin, criterion),
'score_interim': getattr(score_int, criterion) if score_int else '',
'max_score': getattr(score_fin, criterion) == score_fin._meta.get_field(criterion).choices[-1][-1]
})
else:
score_table.append({})
param.score_table = score_table
def _set_last_comment_url(self, parameters, scores):
if self.request.user.executes(self.task) or self.request.user.is_expertA:
scores_with_opened_comments = CommentExmo.objects.filter(
object_pk__in=scores.values_list('pk', flat=True),
content_type__model=ContentType.objects.get_for_model(Score),
status=CommentExmo.OPEN,
user__groups__name=UserProfile.organization_group,
).values_list('object_pk', flat=True)
if scores_with_opened_comments:
scores_with_opened_comments = [int(s) for s in set(scores_with_opened_comments)]
for param in parameters:
if not getattr(param, 'score_pk', None):
continue
if param.score_pk in scores_with_opened_comments:
param.comment_url = reverse('exmo2010:score', args=[param.score_pk]) + "#last_comment"
class TaskScoresView(TaskScoresMixin, DetailView):
template_name = "scores/task_scores.html"
def post(self, request, *args, **kwargs):
scores_table_columns_form = task_scores_columns_form(request)
if scores_table_columns_form.post_ok(request):
return HttpResponseRedirect(request.path)
else:
return HttpResponseBadRequest()
def get_context_data(self, **kwargs):
context = super(TaskScoresView, self).get_context_data(**kwargs)
monitoring = self.task.organization.monitoring
self.queryform = ParametersQueryForm(self.request.GET)
# These fields should be annotated on paramter for strict pedantic tests.
_param_extra = {
'select': {
'comment_url': 0,
'score_pk': 0,
'score_table': 0,
'score_openness': 0,
'score_openness_delta': 0
}
}
# Relevant parameters
relevant_parameters = Parameter.objects.filter(monitoring=monitoring)\
.exclude(exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_rel = Score.objects.filter(task=self.task)\
.exclude(parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
relevant_parameters_exist = relevant_parameters.exists()
# Apply user provided filters to relevant parameters
if self.queryform.is_valid():
relevant_parameters = self.queryform.apply(relevant_parameters)
# Set scores to relevant parameters list
self._set_parameters_scores(relevant_parameters, scores_rel)
self._set_last_comment_url(relevant_parameters, scores_rel)
if self.request.user.is_expert:
# Non relevant parameters
nonrelevant_parameters = Parameter.objects.filter(monitoring=monitoring, exclude=self.task.organization)\
.defer('grounds', 'rating_procedure', 'notes')\
.extra(**_param_extra)
scores_nonrel = Score.objects.filter(task=self.task, parameter__exclude=self.task.organization)\
.defer('links', 'recommendations', 'created', 'last_modified', 'editor')
nonrelevant_parameters_exist = nonrelevant_parameters.exists()
# Apply user provided filters to non relevant parameters
if self.queryform.is_valid():
nonrelevant_parameters = self.queryform.apply(
nonrelevant_parameters)
# Set scores to non relevant parameters list
self._set_parameters_scores(nonrelevant_parameters, scores_nonrel)
context.update({
'nonrelevant_parameters':
nonrelevant_parameters,
'nonrelevant_parameters_exist':
nonrelevant_parameters_exist,
})
# Get questionnaire form
questionnaire_form = None
questions = QQuestion.objects.filter(
questionnaire__monitoring=monitoring).order_by("pk")
if questions:
existing_answers = QAnswer.objects.filter(
task=self.task).order_by("pk")
initial_data = {
"q_%s" % a.question.pk: a.answer(True)
for a in existing_answers
}
questionnaire_form = QuestionnaireDynForm(questions=questions,
initial=initial_data)
context.update({
'relevant_parameters':
relevant_parameters,
'relevant_parameters_exist':
relevant_parameters_exist,
'mon':
monitoring,
'task':
self.task,
'questionnaire_form':
questionnaire_form,
'invcodeform':
SettingsInvCodeForm(),
'orgs_count':
Organization.objects.filter(monitoring=monitoring).count(),
'openness':
self.task.openness,
'delta':
self.task.openness - self.task.openness_initial
if self.task.openness is not None else None,
'columns_form':
task_scores_columns_form(self.request),
'is_representative':
self.request.user.represents(self.task.organization),
})
return context
@staticmethod
def _set_parameters_scores(parameters, scores):
score_fin_dict = {
s.parameter.pk: s
for s in scores if s.revision == Score.FINAL
}
score_int_dict = {
s.parameter.pk: s
for s in scores if s.revision == Score.INTERIM
}
for param in parameters:
score_fin = score_fin_dict.get(param.pk, None)
if score_fin:
param.score_pk = score_fin.pk
param.score_accomplished = score_fin.accomplished
score_int = score_int_dict.get(param.pk, None)
param.score_openness = score_fin.openness
param.score_openness_delta = score_fin.openness - score_int.openness if score_int else 0
criteria = ['found'] + filter(param.__getattribute__,
Parameter.OPTIONAL_CRITERIA)
score_table = []
for criterion in ['found'] + Parameter.OPTIONAL_CRITERIA:
if criterion in criteria:
score_table.append({
'score_final':
getattr(score_fin, criterion),
'score_interim':
getattr(score_int, criterion) if score_int else '',
'max_score':
getattr(score_fin,
criterion) == score_fin._meta.get_field(
criterion).choices[-1][-1]
})
else:
score_table.append({})
param.score_table = score_table
def _set_last_comment_url(self, parameters, scores):
if self.request.user.executes(
self.task) or self.request.user.is_expertA:
scores_with_opened_comments = CommentExmo.objects.filter(
object_pk__in=scores.values_list('pk', flat=True),
content_type__model=ContentType.objects.get_for_model(Score),
status=CommentExmo.OPEN,
user__groups__name=UserProfile.organization_group,
).values_list('object_pk', flat=True)
if scores_with_opened_comments:
scores_with_opened_comments = [
int(s) for s in set(scores_with_opened_comments)
]
for param in parameters:
if not getattr(param, 'score_pk', None):
continue
if param.score_pk in scores_with_opened_comments:
param.comment_url = reverse('exmo2010:score',
args=[param.score_pk
]) + "#last_comment"
