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 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')]