def _get_map_offer_year_entity_type_with_entity(off_year):
off_year_entity_manag = offer_year_entity.get_from_offer_year_and_type(off_year, ENTITY_MANAGEMENT)
entity_version_management = entity_version.get_last_version(off_year_entity_manag.entity)
off_year_entity_admin = offer_year_entity.get_from_offer_year_and_type(off_year, ENTITY_ADMINISTRATION)
entity_version_admin = entity_version.get_last_version(off_year_entity_admin.entity)
return {
ENTITY_MANAGEMENT: entity_version_management.entity_id,
ENTITY_MANAGEMENT_PARENT: entity_version_management.parent_id,
ENTITY_ADMINISTRATION: entity_version_admin.entity_id,
ENTITY_ADMINISTRATION_PARENT: entity_version_admin.parent_id,
}
def get_queryset(self):
rev = reviewer.find_by_person(self.request.user.person)
entities_version = entity_version.get_last_version(rev.entity).children
entities = [this_entity_version.entity for this_entity_version in entities_version]
entities.insert(0, entity_version.get_last_version(rev.entity).entity)
queryset = [{
'id': entity.id,
'title': entity_version.get_last_version(entity, None).title,
'acronym': entity.most_recent_acronym,
'has_already_delegate': reviewer.get_delegate_for_entity(rev, entity)
} for entity in entities]
return queryset
def review_view(request):
mandate_id = request.POST.get("mandate_id")
role = request.POST.get("role")
mandate = assistant_mandate.find_mandate_by_id(mandate_id)
current_reviewer = reviewer.find_by_person(request.user.person)
entity = entity_version.get_last_version(current_reviewer.entity)
current_role = current_reviewer.role
if role == reviewer_role.PHD_SUPERVISOR:
try:
current_review = review.find_done_by_supervisor_for_mandate(mandate)
except ObjectDoesNotExist:
current_review = None
else:
current_review = review.find_review_for_mandate_by_role(mandate, role)
assistant = mandate.assistant
menu = generate_reviewer_menu_tabs(current_role, mandate, role)
return render(request, 'review_view.html', {'review': current_review,
'role': current_role,
'menu': menu,
'menu_type': 'reviewer_menu',
'mandate_id': mandate.id,
'mandate_state': mandate.state,
'current_reviewer': current_reviewer,
'entity': entity,
'assistant': assistant,
'year': mandate.academic_year.year + 1
})
def latest_entity_version_name(self, obj):
entity_v = entity_version.get_last_version(obj.entity)
if entity_v:
entity_v_str = "{}".format(entity_v.acronym)
else:
entity_v_str = "Not found"
return entity_v_str
def pst_form_view(request):
mandate_id = request.POST.get("mandate_id")
mandate = assistant_mandate.find_mandate_by_id(mandate_id)
current_reviewer = reviewer.find_by_person(request.user.person)
current_role = current_reviewer.role
entity = entity_version.get_last_version(current_reviewer.entity)
entities = get_entities_for_mandate(mandate)
learning_units = tutoring_learning_unit_year.find_by_mandate(mandate)
phd_files = assistant_document_file.find_by_assistant_mandate_and_description(mandate,
document_type.PHD_DOCUMENT)
research_files = assistant_document_file.find_by_assistant_mandate_and_description(mandate,
document_type.RESEARCH_DOCUMENT)
tutoring_files = assistant_document_file.find_by_assistant_mandate_and_description(mandate,
document_type.TUTORING_DOCUMENT)
assistant = mandate.assistant
menu = generate_reviewer_menu_tabs(current_role, mandate, None)
return render(request, 'pst_form_view.html', {'menu': menu,
'menu_type': 'reviewer_menu',
'mandate_id': mandate.id,
'assistant': assistant, 'mandate': mandate,
'learning_units': learning_units,
'entity': entity,
'entities': entities,
'phd_files': phd_files,
'assistant_mandate_renewal': assistant_mandate_renewal,
'research_files': research_files,
'tutoring_files': tutoring_files,
'current_reviewer': current_reviewer,
'role': current_role,
'year': mandate.academic_year.year + 1})
def __init__(self, *args, **kwargs):
if not kwargs.get('instance'):
raise ImproperlyConfigured("This form allow update only")
super().__init__(*args, **kwargs)
if self.instance.publication_contact_entity:
self.initial['publication_contact_entity'] = get_last_version(self.instance.publication_contact_entity)
def get_context_data(self, **kwargs):
context = super(StructuresListView, self).get_context_data(**kwargs)
context['year'] = academic_year.current_academic_year().year
context['current_reviewer'] = reviewer.find_by_person(self.request.user.person)
entity = entity_version.get_last_version(context['current_reviewer'].entity)
context['entity'] = entity
context['is_supervisor'] = is_supervisor(self.request.user.person)
return context
def send_message_to_reviewers(request):
html_template_ref = 'assistant_reviewers_startup_html'
txt_template_ref = 'assistant_reviewers_startup_txt'
reviewers = reviewer.find_reviewers()
for rev in reviewers:
send_message(rev.person, html_template_ref, txt_template_ref, role=rev.role,
entity=entity_version.get_last_version(rev.entity).acronym)
save_message_history(request, message_type.TO_ALL_REVIEWERS)
return redirect('messages_history')
def __init__(self, *args, **kwargs):
self.person = kwargs.pop('person')
super().__init__(*args, prefix=self.entity_type.lower(), **kwargs)
self.fields['entity'].label = EntityContainerYearLinkTypes[self.entity_type].value
self.instance.type = self.entity_type
if hasattr(self.instance, 'entity'):
self.initial['entity'] = get_last_version(self.instance.entity).pk
def can_delegate_to_entity(reviewer, entity):
if not can_delegate(reviewer):
return False
current_version = entity_version.get_last_version(entity)
if entity == reviewer.entity:
return True
if current_version.parent == reviewer.entity:
return True
else:
return False
def test_context_data(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.get('/assistants/reviewer/delegation/')
entities_version = entity_version.get_last_version(self.reviewer.entity).children
entities = [this_entity_version.entity for this_entity_version in entities_version]
entities.insert(0, entity_version.get_last_version(self.reviewer.entity).entity)
queryset = [{
'id': entity.id,
'title': entity_version.get_last_version(entity, None).title,
'acronym': entity.most_recent_acronym,
'has_already_delegate': get_delegate_for_entity(self.reviewer, entity)
} for entity in entities]
self.assertQuerysetEqual(response.context['object_list'],
queryset,
transform=lambda x: x
)
self.assertEqual(response.context['entity'], entity_version.get_last_version(self.reviewer.entity))
self.assertEqual(response.context['year'], self.current_academic_year.year)
self.assertEqual(response.status_code, HTTP_OK)
self.assertEqual(response.context['current_reviewer'], find_by_person(self.reviewer.person))
self.assertEqual(response.context['is_supervisor'], is_supervisor(self.reviewer.person))
def __init__(self, data, person, *args, **kwargs):
self.person = person
super().__init__(data, *args, **kwargs)
self.instance.author = person
self.fields['requesting_entity'].queryset = self.person.find_main_entities_version
self.fields['co_graduation'].initial = True
self.fields['co_graduation'].disabled = True
self.fields['mobility'].disabled = True
if self.instance.id and hasattr(self.instance, 'requesting_entity'):
self.initial['requesting_entity'] = get_last_version(self.instance.requesting_entity)
def review_save(request):
mandate_id = request.POST.get("mandate_id")
review_id = request.POST.get("review_id")
rev = review.find_by_id(review_id)
mandate = assistant_mandate.find_mandate_by_id(mandate_id)
current_reviewer = reviewer.find_by_person(request.user.person)
form = ReviewForm(data=request.POST, instance=rev, prefix='rev')
previous_mandates = assistant_mandate.find_before_year_for_assistant(mandate.academic_year.year, mandate.assistant)
role = current_reviewer.role
entity = entity_version.get_last_version(current_reviewer.entity)
menu = generate_reviewer_menu_tabs(role, mandate, role)
if form.is_valid():
current_review = form.save(commit=False)
if 'validate_and_submit' in request.POST:
if current_review.advice not in assistant_mandate_renewal.ASSISTANT_MANDATE_RENEWAL_TYPES:
errors = form._errors.setdefault("advice", ErrorList())
errors.append(_('advice_missing_in_form'))
return render(request, "review_form.html", {'review': rev,
'role': mandate.state,
'year': mandate.academic_year.year + 1,
'absences': mandate.absences,
'comment': mandate.comment,
'reviewer_role': reviewer_role,
'can_validate': reviewer.can_validate(current_reviewer),
'mandate_id': mandate.id,
'previous_mandates': previous_mandates,
'assistant': mandate.assistant,
'entity': entity,
'menu': menu,
'menu_type': 'reviewer_menu',
'form': form})
current_review.reviewer = current_reviewer
validate_review_and_update_mandate(current_review, mandate)
return HttpResponseRedirect(reverse("reviewer_mandates_list_todo"))
elif 'save' in request.POST:
current_review.reviewer = current_reviewer
current_review.status = review_status.IN_PROGRESS
current_review.save()
return review_edit(request)
else:
return render(request, "review_form.html", {'review': rev,
'role': mandate.state,
'year': mandate.academic_year.year + 1,
'absences': mandate.absences,
'comment': mandate.comment,
'reviewer_role': reviewer_role,
'mandate_id': mandate.id,
'previous_mandates': previous_mandates,
'assistant': mandate.assistant,
'entity': entity,
'menu': menu,
'menu_type': 'reviewer_menu',
'form': form})
def get_context_data(self, **kwargs):
context = super(MandatesListView, self).get_context_data(**kwargs)
current_reviewer = reviewer.find_by_person(self.request.user.person)
can_delegate = reviewer.can_delegate(current_reviewer)
context['can_delegate'] = can_delegate
context['reviewer'] = current_reviewer
entity = entity_version.get_last_version(current_reviewer.entity)
context['entity'] = entity
context['is_supervisor'] = self.is_supervisor
context['review_status'] = review_status
context['review_advice_choices'] = review_advice_choices
context['filter'] = self.kwargs.get("filter", None)
context['year'] = academic_year.find_academic_year_by_id(
self.request.session.get('selected_academic_year')).year
context = add_entities_version_to_mandates_list(context)
return add_actions_to_mandates_list(context, current_reviewer)
def get_review_details_for_mandate(mandate, rev):
if rev.reviewer is None:
person = "{} {}<br/>({})".format(
mandate.assistant.supervisor.first_name,
mandate.assistant.supervisor.last_name,
str(_('supervisor'))
)
else:
person = "{} {}<br/>({})".format(
rev.reviewer.person.first_name,
rev.reviewer.person.last_name,
entity_version.get_last_version(rev.reviewer.entity).acronym
)
reviewer = format_data(person, 'reviewer')
remark = format_data(rev.remark, 'remark')
justification = format_data(rev.justification, 'justification')
confidential = format_data(rev.confidential, 'confidential')
return reviewer + remark + justification + confidential
def get_score_sheet_address(off_year):
address = score_sheet_address.get_from_offer_year(off_year)
entity_id = None
if address is None:
address = off_year.id
else:
if address and not address.customized:
map_offer_year_entity_type_with_entity_id = _get_map_offer_year_entity_type_with_entity(off_year)
entity_id = map_offer_year_entity_type_with_entity_id[address.entity_address_choice]
ent_version = entity_version.get_last_version(entity_id)
entity = entity_model.get_by_internal_id(entity_id)
if not entity: # Case no address found for this entity
entity = entity_model.Entity()
email = address.email
address = entity
address.recipient = '{} - {}'.format(ent_version.acronym, ent_version.title)
address.email = email
return {'entity_id_selected': entity_id,
'address': _get_address_as_dict(address)}
def reviewers_index(request):
all_reviewers = reviewer.find_reviewers()
initial_formset_content = [{'action': None,
'entity': rev.entity,
'entity_version': entity_version.get_last_version(rev.entity),
'role': rev.role,
'person': rev.person,
'id': rev.id,
} for rev in all_reviewers]
reviewers_formset = formset_factory(ReviewersFormset, extra=0)(initial=initial_formset_content)
for form in reviewers_formset:
current_reviewer = reviewer.find_by_id(form['id'].value())
if review.find_by_reviewer(current_reviewer).count() == 0:
form.fields['action'].choices = (('-----', _('-----')), ('DELETE', _('delete')),
('REPLACE', _('replace')))
else:
form.fields['action'].choices = (('-----', _('-----')), ('REPLACE', _('replace')))
return render(request, "reviewers_list.html", {'reviewers_formset': reviewers_formset
})
def reviewer_action(request):
reviewers_formset = formset_factory(ReviewersFormset)(request.POST, request.FILES)
if reviewers_formset.is_valid():
for reviewer_form in reviewers_formset:
action = reviewer_form.cleaned_data.get('action')
if action == 'DELETE':
reviewer_delete(request, reviewer_form.cleaned_data.get('id'))
elif action == 'REPLACE':
year = academic_year.current_academic_year().year
reviewer_id = reviewer_form.cleaned_data.get('id')
this_reviewer = reviewer.find_by_id(reviewer_id)
entity = entity_version.get_last_version(this_reviewer.entity)
form = ReviewerReplacementForm(initial={'person': this_reviewer.person,
'id': this_reviewer.id}, prefix="rev",
instance=this_reviewer)
return render(request, "manager_replace_reviewer.html", {'reviewer': this_reviewer,
'entity': entity,
'year': year,
'form': form})
return HttpResponseRedirect(reverse('reviewers_list'))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["secondary_domains"].widget.attrs['placeholder'] = _('Enter text to search')
if getattr(self.instance, 'administration_entity', None):
self.initial['administration_entity'] = get_last_version(self.instance.administration_entity).pk
self.fields['decree_category'].choices = sorted(add_blank(decree_category.DecreeCategories.choices()),
key=lambda c: c[1])
self.fields['rate_code'].choices = sorted(rate_code.RATE_CODE, key=lambda c: c[1])
self.fields['main_domain'].queryset = Domain.objects.filter(type=domain_type.UNIVERSITY)\
.select_related('decree')
if not self.fields['certificate_aims'].disabled:
self.fields['section'].disabled = False
if not getattr(self.initial, 'academic_year', None):
self.set_initial_diploma_values()
if 'instance' in kwargs and not kwargs['instance']:
self.fields['academic_year'].label = _('Start')
def review_edit(request):
mandate_id = request.POST.get("mandate_id")
mandate = assistant_mandate.find_mandate_by_id(mandate_id)
current_reviewer = reviewer.find_by_person(request.user.person)
entity = entity_version.get_last_version(current_reviewer.entity)
delegate_role = current_reviewer.role + "_ASSISTANT"
existing_review = review.find_review_for_mandate_by_role(mandate, delegate_role)
if existing_review is None:
existing_review, created = review.Review.objects.get_or_create(
mandate=mandate,
reviewer=current_reviewer,
status=review_status.IN_PROGRESS
)
previous_mandates = assistant_mandate.find_before_year_for_assistant(mandate.academic_year.year, mandate.assistant)
role = current_reviewer.role
menu = generate_reviewer_menu_tabs(role, mandate, role)
assistant = mandate.assistant
form = ReviewForm(initial={'mandate': mandate,
'reviewer': existing_review.reviewer,
'status': existing_review.status,
'advice': existing_review.advice,
'changed': timezone.now,
'confidential': existing_review.confidential,
'remark': existing_review.remark
}, prefix="rev", instance=existing_review)
return render(request, 'review_form.html', {'review': existing_review,
'role': role,
'year': mandate.academic_year.year + 1,
'absences': mandate.absences,
'comment': mandate.comment,
'reviewer_role': reviewer_role,
'mandate_id': mandate.id,
'previous_mandates': previous_mandates,
'assistant': assistant,
'can_validate': reviewer.can_validate(current_reviewer),
'current_reviewer': current_reviewer,
'entity': entity,
'menu': menu,
'menu_type': 'reviewer_menu',
'form': form})
def reviewer_replace(request):
year = academic_year.current_academic_year().year
form = ReviewerReplacementForm(data=request.POST, prefix='rev')
reviewer_to_replace = reviewer.find_by_id(request.POST.get('reviewer_id'))
entity = entity_version.get_last_version(reviewer_to_replace.entity)
this_person = request.POST.get('person_id')
if form.is_valid() and this_person:
this_person = person.find_by_id(this_person)
if reviewer.find_by_person(this_person):
msg = _("person_already_reviewer_msg")
form.add_error(None, msg)
else:
reviewer_to_replace.person = this_person
reviewer_to_replace.save()
return redirect('reviewers_list')
else:
msg = _("bad_person_msg")
form.add_error(None, msg)
return render(request, "manager_replace_reviewer.html", {'reviewer': reviewer_to_replace,
'entity': entity,
'year': year,
'form': form})
def find_from_offer_year(offer_year):
return [
entity_version.get_last_version(off_year_entity.entity)
for off_year_entity in offer_year_entity.search(
offer_year=offer_year).distinct('entity')
]
def management_entity(self):
result = mdl_offer_year_entity.find_by_education_group_year_first(self, offer_year_entity_type.ENTITY_MANAGEMENT)
if result:
ev = mdl_entity_version.get_last_version(result.entity)
return ev
return None
def entity_last_version(entity):
try:
return entity_version.get_last_version(entity).acronym
except AttributeError:
return None
def __str__(self):
version = entity_version.get_last_version(self.entity)
return u"%s - %s : %s" % (self.person, version.entity, self.role)
def get_entity_version_choices(offer_year):
entity_versions = entity_version_business.find_from_offer_year(offer_year)
return set(entity_versions + [entity_version.get_last_version(ent.parent) for ent in entity_versions])
def _preselect_entity_version_from_entity_value(self):
if getattr(self.instance, 'management_entity', None):
self.initial['management_entity'] = get_last_version(self.instance.management_entity).pk
def administration_entity(self):
result = mdl_offer_year_entity.find_by_education_group_year_first(self, offer_year_entity_type.ENTITY_ADMINISTRATION)
if result:
ev = mdl_entity_version.get_last_version(result.entity)
return ev
return None
def folder(self):
last_entity = entity_version.get_last_version(self.entity)
return "{}{}".format(last_entity.acronym if last_entity else '', str(self.folder_id))
def __str__(self):
version = entity_version.get_by_entity_and_date(self.entity, self.assistant_mandate.academic_year.start_date)
if version is None:
version = entity_version.get_last_version(self.entity)
return u"%s - %s" % (self.assistant_mandate.assistant, version[0].acronym)
def add_reviewer_for_structure(request):
entity_id = request.POST.get("entity_id")
related_entity = entity.get_by_internal_id(entity_id)
current_entity_version = entity_version.get_last_version(
entity.get_by_internal_id(entity_id))
year = academic_year.current_academic_year().year
try:
reviewer.can_delegate_to_entity(
reviewer.find_by_person(request.user.person), related_entity)
except:
return redirect('assistants_home')
if request.POST:
form = ReviewerDelegationForm(data=request.POST)
if form.is_valid():
new_reviewer = form.save(commit=False)
if request.POST.get('person_id'):
this_person = person.find_by_id(request.POST.get('person_id'))
try:
reviewer.find_by_person(this_person)
msg = _("person_already_reviewer_msg")
form.add_error(None, msg)
return render(
request, "reviewer_add_reviewer.html", {
'form':
form,
'year':
year,
'related_entity':
related_entity,
'current_entity_version':
current_entity_version,
'reviewer':
reviewer.find_by_person(request.user.person)
})
except reviewer.Reviewer.DoesNotExist:
pass
new_reviewer.person = this_person
new_reviewer.save()
html_template_ref = 'assistant_reviewers_startup_html'
txt_template_ref = 'assistant_reviewers_startup_txt'
send_message(person=this_person,
html_template_ref=html_template_ref,
txt_template_ref=txt_template_ref)
return redirect('reviewer_delegation')
else:
this_reviewer = reviewer.find_by_person(person=request.user.person)
if this_reviewer.role == reviewer_role.SUPERVISION:
role = reviewer_role.SUPERVISION_ASSISTANT
else:
role = reviewer_role.RESEARCH_ASSISTANT
form = ReviewerDelegationForm(initial={
'entity': related_entity,
'year': year,
'role': role
})
reviewer_entity = entity_version.get_last_version(
this_reviewer.entity)
return render(
request, "reviewer_add_reviewer.html", {
'form': form,
'year': year,
'related_entity': related_entity,
'entity': reviewer_entity,
'current_entity_version': current_entity_version,
'reviewer': reviewer.find_by_person(request.user.person)
})
def folder(self):
last_entity = entity_version.get_last_version(self.instance.entity)
folder = last_entity.acronym if last_entity else ''
folder += str(self.instance.folder_id)
return folder
def _preselect_entity_version_from_entity_value(self):
if getattr(self.instance, 'management_entity', None):
self.initial['management_entity'] = get_last_version(
self.instance.management_entity).pk
def __str__(self):
version = entity_version.get_by_entity_and_date(self.entity, self.assistant_mandate.academic_year.start_date)
if version is None:
version = entity_version.get_last_version(self.entity)
return u"%s - %s" % (self.assistant_mandate.assistant, version[0].acronym)
def __str__(self):
version = entity_version.get_last_version(self.entity)
return u"%s - %s : %s" % (self.person, version.entity, self.role)
def folder(self):
last_entity = entity_version.get_last_version(self.entity)
return "{}{}".format(last_entity.acronym if last_entity else '', str(self.folder_id))
def get_entity_version_choices(offer_year):
entity_versions = entity_version_business.find_from_offer_year(offer_year)
return set(entity_versions + [entity_version.get_last_version(ent.parent) for ent in entity_versions])
def find_from_offer_year(offer_year):
return [entity_version.get_last_version(off_year_entity.entity)
for off_year_entity in offer_year_entity.search(offer_year=offer_year).distinct('entity')]
