def add_reviewer_for_structure(request): current_entity = entity.find_by_id(request.POST.get("entity")) year = academic_year.current_academic_year().year if not reviewer.can_delegate_to_entity(reviewer.find_by_person(request.user.person), current_entity): return redirect('assistants_home') form = ReviewerDelegationForm(data=request.POST) if form.is_valid() and request.POST.get('person_id'): new_reviewer = form.save(commit=False) this_person = person.find_by_id(request.POST.get('person_id')) if 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, 'entity': current_entity, 'reviewer': reviewer.find_by_person(request.user.person) }) 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) role = this_reviewer.role + '_ASSISTANT' form = ReviewerDelegationForm(initial={'entity': current_entity, 'year': year, 'role': role}) return render(request, "reviewer_add_reviewer.html", { 'form': form, 'year': year, 'entity': current_entity, 'reviewer': reviewer.find_by_person(request.user.person) })
def build_doc(request, mandates): year = mandates[0].academic_year filename = ('%s_%s_%s.pdf' % (_('assistants_mandates'), year, time.strftime("%Y%m%d_%H%M"))) response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename="%s"' % filename buffer = BytesIO() doc = SimpleDocTemplate(buffer, pagesize=PAGE_SIZE, rightMargin=MARGIN_SIZE, leftMargin=MARGIN_SIZE, topMargin=70, bottomMargin=25) styles = getSampleStyleSheet() styles.add( ParagraphStyle( name='Tiny', fontSize=6, font='Helvetica', leading=8, leftIndent=0, rightIndent=0, firstLineIndent=0, alignment=TA_LEFT, spaceBefore=0, spaceAfter=0, splitLongWords=1, )) styles.add( ParagraphStyle( name='StandardWithBorder', font='Helvetica', leading=18, leftIndent=10, rightIndent=10, firstLineIndent=0, alignment=TA_JUSTIFY, spaceBefore=25, spaceAfter=5, splitLongWords=1, borderColor='#000000', borderWidth=1, borderPadding=10, )) content = [] if academic_assistant.find_by_person(find_by_user(request.user)): role = user_role.ASSISTANT elif reviewer.find_by_person(find_by_user(request.user)): role = reviewer.find_by_person(find_by_user(request.user)).role else: role = user_role.ADMINISTRATOR for mandate in mandates: add_mandate_content(content, mandate, styles, role) doc.build(content, add_header_footer) pdf = buffer.getvalue() buffer.close() response.write(pdf) return response
def assistant_home(request): if settings.access_to_procedure_is_open( ) and academic_assistant.find_by_person(person=request.user.person): return HttpResponseRedirect(reverse('assistant_mandates')) else: try: manager.find_by_person(person=request.user.person) return HttpResponseRedirect(reverse('manager_home')) except manager.Manager.DoesNotExist: try: reviewer.find_by_person(person=request.user.person) return HttpResponseRedirect( reverse('reviewer_mandates_list_todo')) except reviewer.Reviewer.DoesNotExist: return HttpResponseRedirect(reverse('access_denied'))
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.can_edit_review( reviewer.find_by_person(person.find_by_user(request.user)).id, mandate_id) 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: current_review.status = review_status.DONE current_review.save() if mandate.state == assistant_mandate_state.PHD_SUPERVISOR: if mandate_entity.find_by_mandate_and_type( mandate, entity_type.INSTITUTE): mandate.state = assistant_mandate_state.RESEARCH elif mandate_entity.find_by_mandate_and_type( mandate, entity_type.POLE): mandate.state = assistant_mandate_state.RESEARCH else: mandate.state = assistant_mandate_state.SUPERVISION elif mandate.state == assistant_mandate_state.RESEARCH: mandate.state = assistant_mandate_state.SUPERVISION elif mandate.state == assistant_mandate_state.SUPERVISION: mandate.state = assistant_mandate_state.VICE_RECTOR elif mandate.state == assistant_mandate_state.VICE_RECTOR: mandate.state = assistant_mandate_state.DONE mandate.save() if current_review.reviewer is not None: return HttpResponseRedirect(reverse("reviewer_mandates_list")) else: return HttpResponseRedirect( reverse("phd_supervisor_assistants_list")) elif 'save' in request.POST: 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, 'mandate_id': mandate.id, 'previous_mandates': previous_mandates, 'assistant': mandate.assistant, 'entity': entity, 'menu': menu, 'menu_type': 'reviewer_menu', 'form': form })
def test_context_data(self): response = self.client.get(self.url) self.assertEqual(response.status_code, HttpResponse.status_code) context = response.context entities_vers_qs = entity_version.EntityVersion.objects.filter( pk__in=[self.institute.pk, self.institute_child.pk]) self.assertQuerysetEqual(context['object_list'], entities_vers_qs, transform=lambda x: x, ordered=False) self.assertQuerysetEqual( context["object_list"], [tuple(), (self.research_assistant_reviewer, )], transform=lambda x: tuple(x.entity.delegated_reviewer), ordered=False) self.assertEqual( context['entity'], entity_version.get_last_version(self.research_reviewer.entity)) self.assertEqual(context['year'], self.current_academic_year.year) self.assertEqual(context['current_reviewer'], find_by_person(self.research_reviewer.person)[0]) self.assertFalse(context['is_supervisor'])
def get_context_data(self, **kwargs): context = super(MandatesListView, self).get_context_data(**kwargs) phd_list = ['RESEARCH', 'SUPERVISION', 'VICE_RECTOR', 'DONE'] research_list = ['SUPERVISION', 'VICE_RECTOR', 'DONE'] supervision_list = ['VICE_RECTOR', 'DONE'] vice_rector_list = ['VICE_RECTOR', 'DONE'] 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['phd_list'] = phd_list context['research_list'] = research_list context['supervision_list'] = supervision_list context['vice_rector_list'] = vice_rector_list context['is_supervisor'] = self.is_supervisor context['filter'] = self.kwargs.get("filter", None) context['year'] = academic_year.find_academic_year_by_id( self.request.session.get('selected_academic_year')).year start_date = academic_year.find_academic_year_by_id( int(self.request.session.get('selected_academic_year'))).start_date for mandate in context['object_list']: entities = [] entities_id = mandate.mandateentity_set.all().order_by('id') for entity in entities_id: current_entityversion = entity_version.get_by_entity_and_date( entity.entity, start_date)[0] if current_entityversion is None: current_entityversion = entity_version.get_last_version( entity.entity) entities.append(current_entityversion) mandate.entities = entities return context
def get_queryset(self): form_class = MandatesArchivesForm form = form_class(self.request.GET) current_reviewer = reviewer.find_by_person(self.request.user.person) if len( assistant_mandate.find_for_supervisor_for_academic_year( self.request.user.person, academic_year.current_academic_year())) > 0: self.is_supervisor = True mandates_id = mandate_entity.find_by_entity( current_reviewer.entity).values_list('assistant_mandate_id', flat=True) if form.is_valid(): self.request.session['selected_academic_year'] = form.cleaned_data[ 'academic_year'].id selected_academic_year = academic_year.AcademicYear.objects.get( id=self.request.session.get('selected_academic_year')) elif self.request.session.get('selected_academic_year'): selected_academic_year = academic_year.AcademicYear.objects.get( id=self.request.session.get('selected_academic_year')) else: selected_academic_year = academic_year.current_academic_year() self.request.session[ 'selected_academic_year'] = selected_academic_year.id if self.kwargs.get("filter", None): selected_academic_year = academic_year.current_academic_year() self.request.session[ 'selected_academic_year'] = selected_academic_year.id queryset = assistant_mandate.find_by_academic_year(selected_academic_year).filter(id__in=mandates_id).\ filter(state=current_reviewer.role.replace('_ASSISTANT', '')) else: queryset = assistant_mandate.find_by_academic_year( selected_academic_year).filter(id__in=mandates_id) return queryset
def get_context_data(self, **kwargs): context = super(AssistantsListView, self).get_context_data(**kwargs) context['year'] = academic_year.current_academic_year().year start_date = academic_year.current_academic_year().start_date context['is_reviewer'] = self.is_reviewer context['current_reviewer'] = self.reviewer if self.reviewer: entity = entity_version.get_last_version(self.reviewer.entity) else: entity = None context['entity'] = entity if self.is_reviewer: can_delegate = reviewer.can_delegate( reviewer.find_by_person(self.request.user.person)) context['can_delegate'] = can_delegate else: context['can_delegate'] = False for mandate in context['object_list']: entities = [] entities_id = mandate.mandateentity_set.all().order_by('id') for entity in entities_id: current_entityversion = entity_version.get_by_entity_and_date( entity.entity, start_date)[0] if current_entityversion is None: current_entityversion = entity_version.get_last_version( entity.entity) entities.append(current_entityversion) mandate.entities = entities return context
def add_reviewer_for_structure(request): current_entity = entity.find_by_id(request.POST.get("entity")) year = academic_year.starting_academic_year().year current_reviewer = reviewer_eligible_to_delegate( reviewer.find_by_person(request.user.person), current_entity ) if not current_reviewer: return redirect('assistants_home') form = ReviewerDelegationForm(data=request.POST) if form.is_valid() and request.POST.get('person_id'): new_reviewer = form.save(commit=False) new_reviewer.person = person.find_by_id(request.POST.get('person_id')) new_reviewer.save() send_message( person=new_reviewer.person, html_template_ref='assistant_reviewers_startup_html', txt_template_ref='assistant_reviewers_startup_txt' ) return redirect('reviewer_delegation') role = current_reviewer.role + '_ASSISTANT' form = ReviewerDelegationForm(initial={'entity': current_entity, 'year': year, 'role': role}) return render(request, "reviewer_add_reviewer.html", { 'form': form, 'year': year, 'entity': current_entity, 'reviewer': current_reviewer })
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 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 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: validate_review_and_update_mandate(current_review, mandate) return HttpResponseRedirect(reverse("reviewer_mandates_list_todo")) elif 'save' in request.POST: 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, 'mandate_id': mandate.id, 'previous_mandates': previous_mandates, 'assistant': mandate.assistant, 'entity': entity, 'menu': menu, 'menu_type': 'reviewer_menu', 'form': form})
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 test_func(self): try: if settings.access_to_procedure_is_open(): return reviewer.can_delegate( reviewer.find_by_person(self.request.user.person)) except ObjectDoesNotExist: return False
def get_queryset(self): form_class = MandatesArchivesForm form = form_class(self.request.GET) current_reviewer = reviewer.find_by_person(self.request.user.person) if len(assistant_mandate.find_for_supervisor_for_academic_year(self.request.user.person, academic_year.current_academic_year())) > 0: self.is_supervisor = True mandates_id = mandate_entity.find_by_entity(current_reviewer.entity).values_list( 'assistant_mandate_id', flat=True) if form.is_valid(): self.request.session['selected_academic_year'] = form.cleaned_data[ 'academic_year'].id selected_academic_year = academic_year.AcademicYear.objects.get( id=self.request.session.get('selected_academic_year')) elif self.request.session.get('selected_academic_year'): selected_academic_year = academic_year.AcademicYear.objects.get( id=self.request.session.get('selected_academic_year')) else: selected_academic_year = academic_year.current_academic_year() self.request.session[ 'selected_academic_year'] = selected_academic_year.id if self.kwargs.get("filter", None): selected_academic_year = academic_year.current_academic_year() self.request.session[ 'selected_academic_year'] = selected_academic_year.id queryset = assistant_mandate.find_by_academic_year(selected_academic_year).filter(id__in=mandates_id).\ filter(state=current_reviewer.role.replace('_ASSISTANT', '').replace('_DAF', '')) else: queryset = assistant_mandate.find_by_academic_year(selected_academic_year).filter(id__in=mandates_id) return queryset
def user_is_reviewer_and_procedure_is_open(user): try: if user.is_authenticated() and settings.access_to_procedure_is_open(): return reviewer.find_by_person(user.person) else: return False except ObjectDoesNotExist: return False
def test_context_data_phd_supervisor_is_reviewer(self): self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH, entity=self.entity_version.entity, person=self.phd_supervisor) self.client.force_login(self.phd_supervisor.user) response = self.client.get('/assistants/phd_supervisor/assistants/') self.assertEqual(response.context['current_reviewer'], find_by_person(self.phd_supervisor)) self.assertTrue(response.context['can_delegate'])
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 export_mandates_for_entity(request: http.HttpRequest, year: int): mandates = assistant_mandate.AssistantMandate.objects.filter( mandateentity__entity__in=reviewer.find_by_person( find_by_user(request.user)).values_list("entity", flat=True), academic_year=academic_year.find_academic_year_by_year(year)).order_by( 'assistant__person__last_name') if mandates: return build_doc(request, mandates) return HttpResponseRedirect(reverse('reviewer_mandates_list'))
def get_queryset(self): try: self.reviewer = reviewer.find_by_person(self.request.user.person) self.is_reviewer = True except ObjectDoesNotExist: self.is_reviewer = False self.reviewer = None return assistant_mandate.find_for_supervisor_for_academic_year( self.request.user.person, academic_year.current_academic_year())
def export_mandates_for_entity(request, year): current_reviewer = reviewer.find_by_person(find_by_user(request.user)) mandates = find_mandates_for_academic_year_and_entity( academic_year.find_academic_year_by_year(year), current_reviewer.entity) if mandates: return build_doc(request, mandates) else: return HttpResponseRedirect(reverse('reviewer_mandates_list'))
def export_mandates_for_entity(request, year): current_reviewer = reviewer.find_by_person(find_by_user(request.user)) mandates = find_mandates_for_academic_year_and_entity( academic_year.find_academic_year_by_year(year), current_reviewer.entity ) if mandates: return build_doc(request, mandates) else: return HttpResponseRedirect(reverse('reviewer_mandates_list'))
def test_add_reviewer_for_structure_with_valid_data(self): data = { 'person_id': self.delegate.id, 'entity': self.institute.entity.id, 'role': self.research_reviewer.role } response = self.client.post(self.url, data) self.assertEqual(response.status_code, HttpResponseRedirect.status_code) self.assertTrue(find_by_person(self.delegate))
def get_context_data(self, **kwargs): context = super(AssistantsListView, self).get_context_data(**kwargs) context['year'] = academic_year.current_academic_year().year context['current_reviewer'] = self.reviewer if self.reviewer: can_delegate = reviewer.can_delegate(reviewer.find_by_person(self.request.user.person)) context['can_delegate'] = can_delegate else: context['can_delegate'] = False return add_entities_version_to_mandates_list(context)
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['year'] = academic_year.starting_academic_year().year reviewers = reviewer.find_by_person(self.request.user.person) context['current_reviewer'] = reviewers.first() if reviewers: context['can_delegate'] = any( reviewer.can_delegate(rev) for rev in reviewers) else: context['can_delegate'] = False return add_entities_version_to_mandates_list(context)
def test_can_add_reviewer_for_structure_with_person_already_reviewer(self): data = { 'person_id': self.vice_sector_reviewer.person.id, 'entity': self.institute.entity.id, 'role': self.research_reviewer.role } response = self.client.post(self.url, data) self.assertEqual(response.status_code, HttpResponseRedirect.status_code) self.assertEqual(len(find_by_person(self.vice_sector_reviewer.person)), 2)
def get_queryset(self): if len( assistant_mandate.find_for_supervisor_for_academic_year( self.request.user.person, academic_year.current_academic_year())) > 0: self.is_supervisor = True rev = reviewer.find_by_person(self.request.user.person) main_entity_version = entity_version.get_last_version(rev.entity) queryset = list(main_entity_version.find_direct_children()) queryset.insert(0, main_entity_version) return queryset
def test_add_reviewer_for_structure_with_valid_data(self): self.client.force_login(self.reviewer.person.user) this_entity = find_versions_from_entites([self.entity_factory.id], date=None)[0] response = self.client.post('/assistants/reviewer/delegate/add/', { 'person_id': self.delegate.id, 'entity': this_entity.id, 'role': self.reviewer.role } ) self.assertEqual(response.status_code, HTTP_FOUND) self.assertTrue(find_by_person(self.delegate))
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_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 test_add_reviewer_for_structure_with_valid_data(self): self.client.force_login(self.reviewer.person.user) this_entity = find_versions_from_entites([self.entity_factory.id], date=None)[0] response = self.client.post( '/assistants/reviewer/delegate/add/', { 'person_id': self.delegate.id, 'entity': this_entity.id, 'role': self.reviewer.role }) self.assertEqual(response.status_code, HTTP_FOUND) self.assertTrue(find_by_person(self.delegate))
def build_doc(request, mandates, type='default'): if mandates: year = mandates[0].academic_year else: year = academic_year.current_academic_year() if type is 'export_to_sap': filename = ('%s_%s_%s.pdf' % (mandates[0].sap_id, year, mandates[0].assistant.person)) else: filename = ('%s_%s_%s.pdf' % (_('assistants_mandates'), year, time.strftime("%Y%m%d_%H%M"))) response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename="%s"' % filename buffer = BytesIO() doc = SimpleDocTemplate(buffer, pagesize=PAGE_SIZE, rightMargin=MARGIN_SIZE, leftMargin=MARGIN_SIZE, topMargin=70, bottomMargin=25) styles = getSampleStyleSheet() styles.add(ParagraphStyle(name='Tiny', fontSize=6, font='Helvetica', leading=8, leftIndent=0, rightIndent=0, firstLineIndent=0, alignment=TA_LEFT, spaceBefore=0, spaceAfter=0, splitLongWords=1, )) styles.add(ParagraphStyle(name='StandardWithBorder', font='Helvetica', leading=18, leftIndent=10, rightIndent=10, firstLineIndent=0, alignment=TA_JUSTIFY, spaceBefore=25, spaceAfter=5, splitLongWords=1, borderColor='#000000', borderWidth=1, borderPadding=10, )) content = [] if academic_assistant.find_by_person(find_by_user(request.user)): role = user_role.ASSISTANT elif reviewer.find_by_person(find_by_user(request.user)): role = reviewer.find_by_person(find_by_user(request.user)).role else: role = user_role.ADMINISTRATOR if type is 'default' or type is 'export_to_sap': for mandate in mandates: add_mandate_content(content, mandate, styles, role) else: content.append(create_paragraph("%s (%s)<br />" % (_('declined_mandates'), year), '', styles["BodyText"])) if mandates: write_table(content, add_declined_mandates(mandates, styles['Tiny']), COLS_WIDTH_FOR_DECLINED_MANDATES) content.append(PageBreak()) doc.build(content, add_header_footer) pdf = buffer.getvalue() buffer.close() response.write(pdf) return response
def test_context_data_phd_supervisor_is_not_reviewer(self): self.client.force_login(self.phd_supervisor.user) response = self.client.get('/assistants/phd_supervisor/assistants/') self.assertEqual(response.status_code, HTTP_OK) self.assertEqual(response.context['current_reviewer'], find_by_person(self.phd_supervisor)) self.assertFalse(response.context['can_delegate']) entities_id = self.assistant_mandate.mandateentity_set.all().order_by('id').values_list('entity', flat=True) self.assistant_mandate.entities = find_versions_from_entites(entities_id, None) self.assistant_mandate.save() self.assertQuerysetEqual(response.context['object_list'], find_for_supervisor_for_academic_year(self.phd_supervisor, self.current_academic_year), transform = lambda x: x )
def assistant_home(request): if (settings.access_to_procedure_is_open() or settings.assistants_can_see_file()) \ and academic_assistant.find_by_person(person=request.user.person): return HttpResponseRedirect(reverse('assistant_mandates')) else: try: manager.find_by_person(person=request.user.person) return HttpResponseRedirect(reverse('manager_home')) except manager.Manager.DoesNotExist: if reviewer.find_by_person(person=request.user.person): return HttpResponseRedirect(reverse('reviewer_mandates_list_todo')) else: return HttpResponseRedirect(reverse('access_denied'))
def test_context_data(self): self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH, entity=self.entity_version.entity, person=self.phd_supervisor) self.client.force_login(self.phd_supervisor.user) response = self.client.get('/assistants/reviewer/') self.assertEqual(response.context['reviewer'], find_by_person(self.phd_supervisor)) self.assertTrue(response.context['can_delegate']) mandates_id = find_by_entity(self.reviewer.entity).values_list( 'assistant_mandate_id', flat=True) self.assertQuerysetEqual(response.context['object_list'], find_by_academic_year(self.current_academic_year).filter(id__in=mandates_id), transform=lambda x: x )
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['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 test_context_data(self): self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH, entity=self.entity_version.entity, person=self.phd_supervisor) self.client.force_login(self.phd_supervisor.user) response = self.client.get('/assistants/reviewer/') self.assertEqual(response.context['reviewer'], find_by_person(self.phd_supervisor)) self.assertTrue(response.context['can_delegate']) mandates_id = find_by_entity(self.reviewer.entity).values_list( 'assistant_mandate_id', flat=True) self.assertQuerysetEqual( response.context['object_list'], find_by_academic_year( self.current_academic_year).filter(id__in=mandates_id), transform=lambda x: x)
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 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 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 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 reviewer_add(request): year = academic_year.current_academic_year().year if request.POST: form = ReviewerForm(data=request.POST) this_person = request.POST.get('person_id') if form.is_valid() and this_person: this_person = person.find_by_id(this_person) new_reviewer = form.save(commit=False) if reviewer.find_by_person(this_person): msg = _("person_already_reviewer_msg") form.add_error(None, msg) if reviewer.find_by_entity_and_role(new_reviewer.entity, new_reviewer.role): msg = _("reviewer_with_same_role_already_exists_msg") form.add_error(None, msg) if not form.has_error(field=NON_FIELD_ERRORS): new_reviewer.person = this_person new_reviewer.save() return redirect('reviewers_list') else: msg = _("bad_person_msg") form.add_error(None, msg) else: form = ReviewerForm(initial={'year': year}) return render(request, "manager_add_reviewer.html", {'form': form, 'year': year})
def test_find_by_person(self): self.assertEqual(self.reviewer1, reviewer.find_by_person(self.reviewer1.person))
def get_queryset(self): self.reviewer = reviewer.find_by_person(self.request.user.person) return assistant_mandate.find_for_supervisor_for_academic_year(self.request.user.person, academic_year.current_academic_year())
def user_is_reviewer_and_procedure_is_open(user): return user.is_authenticated and settings.access_to_procedure_is_open() and reviewer.find_by_person(user.person)