def apply_learning_unit_year_postponement(self, request, queryset): # Potential circular imports from base.business.learning_units.automatic_postponement import LearningUnitAutomaticPostponementToN6 from base.views.common import display_success_messages, display_error_messages result, errors = LearningUnitAutomaticPostponementToN6(queryset).postpone() count = len(result) display_success_messages( request, ngettext( '%(count)d learning unit has been postponed with success', '%(count)d learning units have been postponed with success', count ) % {'count': count} ) if errors: display_error_messages(request, "{} : {}".format( _("The following learning units ended with error"), ", ".join([str(error) for error in errors]) ))
def apply_learning_unit_year_postponement(self, request, queryset): # Potential circular imports from base.business.learning_units.automatic_postponement import LearningUnitAutomaticPostponement from base.views.common import display_success_messages, display_error_messages result, errors = LearningUnitAutomaticPostponement(queryset).postpone() count = len(result) display_success_messages( request, ngettext( '%(count)d learning unit has been postponed with success', '%(count)d learning units have been postponed with success', count) % {'count': count}) if errors: display_error_messages( request, "{} : {}".format( _("The following learning units ended with error"), ", ".join([str(error) for error in errors])))
def add_continuing_education_training_manager(request): errors = [] person_training_form = PersonTrainingForm(request.POST or None) if person_training_form.is_valid(): person = person_training_form.cleaned_data['person'] _append_user_to_training_managers(person.user) person_training_form.save() success_msg = _( 'Successfully assigned %(manager)s to the training %(training)s' ) % { "manager": person, "training": person_training_form.cleaned_data['training'].acronym } display_success_messages(request, success_msg) else: errors.append(person_training_form.errors) display_errors(request, errors) return redirect(list_managers)
def copy_reddot_data(self, request, queryset): # Potential circular imports from base.business.education_groups.automatic_postponement import ReddotEducationGroupAutomaticPostponement from base.views.common import display_success_messages, display_error_messages result, errors = ReddotEducationGroupAutomaticPostponement(queryset).postpone() count = len(result) display_success_messages( request, ngettext( "%(count)d education group has been updated with success.", "%(count)d education groups have been updated with success.", count ) % {'count': count} ) if errors: display_error_messages(request, "{} : {}".format( _("The following education groups ended with error"), ", ".join([str(error) for error in errors]) ))
def post(self, request, **kwargs): try: postponer = PostponeContent(self.get_root().previous_year()) postponer.postpone() count = len(postponer.result) success = ngettext( "%(count)d education group has been postponed with success.", "%(count)d education groups have been postponed with success.", count) % { 'count': count } display_success_messages(request, success) except NotPostponeError as e: display_error_messages(request, str(e)) return redirect( reverse( "education_group_read", args=[kwargs["root_id"], kwargs["education_group_year_id"]]))
def _common_success_redirect(request, form, parent=None): education_group_year = form.save() parent_id = parent.pk if parent else education_group_year.pk success_msg = [ _get_success_message_for_creation_education_group_year( parent_id, education_group_year) ] if hasattr(form, 'education_group_year_postponed'): success_msg += [ _get_success_message_for_creation_education_group_year( egy.id, egy) for egy in form.education_group_year_postponed ] display_success_messages(request, success_msg, extra_tags='safe') # Redirect url = reverse("education_group_read", args=[parent_id, education_group_year.pk]) return redirect(url)
def apply_education_group_year_postponement(self, request, queryset): # Potential circular imports from base.business.education_groups.automatic_postponement import EducationGroupAutomaticPostponement from base.views.common import display_success_messages, display_error_messages result, errors = EducationGroupAutomaticPostponement( queryset).postpone() count = len(result) display_success_messages( request, ngettext( "%(count)d education group has been postponed with success.", "%(count)d education groups have been postponed with success.", count) % {'count': count}) if errors: display_error_messages( request, "{} : {}".format( _("The following education groups ended with error"), ", ".join([str(error) for error in errors])))
def entity_read(request, entity_version_id): entity_version = get_object_or_404(EntityVersion, id=entity_version_id) can_user_post = can_user_edit_educational_information_submission_dates_for_entity(request.user, entity_version.entity) if request.method == "POST" and not can_user_post: logger.warning("User {} has no sufficient right to modify submission dates of educational information.". format(request.user)) raise PermissionDenied() entity_parent = entity_version.get_parent_version() descendants = entity_version.descendants form = EntityCalendarEducationalInformationForm(entity_version, request.POST or None) if form.is_valid(): display_success_messages(request, _("Educational information submission dates updated")) form.save_entity_calendar(entity_version.entity) # TODO Remove locals return render(request, "entity/identification.html", locals())
def update_learning_unit_pedagogy(request, learning_unit_year_id, context, template): person = get_object_or_404(Person, user=request.user) context.update( get_common_context_learning_unit_year(learning_unit_year_id, person)) learning_unit_year = context['learning_unit_year'] perm_to_edit = int(request.user.has_perm('can_edit_learningunit_pedagogy')) post = request.POST or None summary_form = SummaryModelForm(post, person, context['is_person_linked_to_entity'], instance=learning_unit_year) BibliographyFormset = inlineformset_factory(LearningUnitYear, Bibliography, fields=('title', 'mandatory'), max_num=10, extra=perm_to_edit, form=BibliographyModelForm, can_delete=perm_to_edit) bibliography_formset = BibliographyFormset(post, instance=learning_unit_year, form_kwargs={'person': person}) if perm_to_edit and summary_form.is_valid( ) and bibliography_formset.is_valid(): try: summary_form.save() bibliography_formset.save() display_success_messages(request, _("success_modification_learning_unit")) # Redirection on the same page return HttpResponseRedirect(request.path_info) except ValueError as e: display_error_messages(request, e.args[0]) context.update(get_cms_pedagogy_form(request, learning_unit_year)) context['summary_editable_form'] = summary_form context['bibliography_formset'] = bibliography_formset return layout.render(request, template, context)
def _update_proposal(request, user_person, proposal): initial_data = compute_form_initial_data(proposal.learning_unit_year) initial_data.update(_build_proposal_data(proposal)) # Workaround Set initial data from proposal initial data json to compute effectively data modified # and compute proposal type initial_data_from_json = compute_form_initial_data_from_proposal_json( proposal.initial_data) initial_data_from_json.update(_build_proposal_data(proposal)) proposal_form = LearningUnitProposalModificationForm( request.POST or None, initial=initial_data_from_json, instance=proposal, learning_unit=proposal.learning_unit_year.learning_unit, person=user_person) if proposal_form.is_valid(): try: changed_fields = proposal_form.changed_data_for_fields_that_can_be_modified type_proposal = business_proposal.compute_proposal_type( changed_fields, initial_data_from_json.get("type")) proposal_form.save(proposal.learning_unit_year, type_proposal, proposal_form.cleaned_data.get("state")) display_success_messages(request, _("proposal_edited_successfully")) return HttpResponseRedirect( reverse('learning_unit', args=[proposal.learning_unit_year.id])) except (IntegrityError, ValueError) as e: display_error_messages(request, e.args[0]) proposal_form.initial = initial_data return layout.render( request, 'learning_unit/proposal/update_modification.html', { 'learning_unit_year': proposal.learning_unit_year, 'person': user_person, 'form': proposal_form, 'experimental_phase': True })
def _display_adapted_ucl_registration_message(admission, request): if admission.ucl_registration_complete == UCLRegistrationState.SENDED.name: display_warning_messages(request, _('Folder sended to EPC : waiting for response')) elif admission.ucl_registration_complete == UCLRegistrationState.REJECTED.name: display_error_messages( request, _('Folder injection into EPC failed : %(reasons)s') % { 'reasons': admission.get_ucl_registration_error_display() } ) elif admission.ucl_registration_complete == UCLRegistrationState.DEMANDE.name: display_info_messages(request, _('Folder injection into EPC succeeded : UCLouvain registration on demand')) elif admission.ucl_registration_complete == UCLRegistrationState.INSCRIT.name: display_success_messages(request, _('Folder injection into EPC succeeded : UCLouvain registration completed')) elif admission.ucl_registration_complete != UCLRegistrationState.INIT_STATE.name: display_info_messages( request, _('Folder injection into EPC succeeded : UCLouvain registration status : %(status)s') % { 'status': admission.get_ucl_registration_complete_display() } )
def get_proposal_learning_unit_creation_form(request, academic_year): person = get_object_or_404(Person, user=request.user) academic_year_pk = request.POST.get('academic_year', academic_year) academic_year = get_object_or_404(AcademicYear, pk=academic_year_pk) proposal_form = CreationProposalBaseForm(request.POST or None, person, academic_year) if request.method == 'POST': if proposal_form.is_valid(): proposal = proposal_form.save() success_msg = _( "Proposal learning unit <a href='%(link)s'> %(acronym)s (%(academic_year)s) </a> successfuly created.")\ % { 'link': reverse("learning_unit", kwargs={'learning_unit_year_id': proposal.learning_unit_year.id}), 'acronym': proposal.learning_unit_year.acronym, 'academic_year': proposal.learning_unit_year.academic_year } display_success_messages(request, success_msg, extra_tags='safe') return redirect('learning_unit', learning_unit_year_id=proposal.learning_unit_year.pk) else: show_error_message_for_form_invalid(request) return render(request, "learning_unit/proposal/creation.html", proposal_form.get_context())
def publish(request, education_group_year_id, root_id): education_group_year = get_object_or_404(EducationGroupYear, pk=education_group_year_id) try: general_information.publish(education_group_year) message = _("The program %(acronym)s will be published soon") % { 'acronym': education_group_year.acronym } display_success_messages(request, message, extra_tags='safe') except PublishException as e: display_error_messages(request, str(e)) default_redirect_view = reverse('education_group_general_informations', kwargs={ 'root_id': root_id, 'education_group_year_id': education_group_year_id }) return HttpResponseRedirect( request.META.get('HTTP_REFERER', default_redirect_view))
def post(self, request, **kwargs): try: postponer = PostponeContent(self.root.previous_year()) postponer.postpone() success = _( "%(count_elements)s OF(s) and %(count_links)s link(s) have been postponed with success." ) % { 'count_elements': postponer.number_elements_created, 'count_links': postponer.number_links_created } display_success_messages(request, success) display_warning_messages(request, postponer.warnings) except NotPostponeError as e: display_error_messages(request, str(e)) return JsonResponse({ 'success_url': reverse( "education_group_read", args=[kwargs["root_id"], kwargs["education_group_year_id"]]) })
def learning_unit_edition_end_date(request, learning_unit_year_id): learning_unit_year = get_object_or_404(LearningUnitYear, pk=learning_unit_year_id) person = get_object_or_404(Person, user=request.user) context = get_learning_unit_identification_context(learning_unit_year_id, person) learning_unit_to_edit = learning_unit_year.learning_unit form = LearningUnitEndDateForm(request.POST or None, learning_unit_year=learning_unit_year) if form.is_valid(): try: result = form.save() display_success_messages(request, result, extra_tags='safe') learning_unit_year_id = _get_current_learning_unit_year_id(learning_unit_to_edit, learning_unit_year_id) return HttpResponseRedirect(reverse('learning_unit', args=[learning_unit_year_id])) except IntegrityError as e: display_error_messages(request, e.args[0]) context['form'] = form return render(request, 'learning_unit/simple/update_end_date.html', context)
def _update_or_create_proposal(request, learning_unit_year, proposal=None): person = get_object_or_404(Person, user=request.user) proposal_base_form = ProposalBaseForm(request.POST or None, person, learning_unit_year, proposal) if proposal_base_form.is_valid(): proposal = proposal_base_form.save() display_success_messages( request, _("You proposed a modification of type {} for the learning unit {}." ).format(_(proposal.type), learning_unit_year.acronym)) return redirect('learning_unit', learning_unit_year_id=learning_unit_year.id) context = proposal_base_form.get_context() if proposal: return render(request, 'learning_unit/proposal/update_modification.html', context) return render(request, 'learning_unit/proposal/create_modification.html', context)
def list_managers(request): search_form = ManagerFilterForm(data=request.GET) person_training_form = PersonTrainingForm(request.POST or None) trainings = ContinuingEducationTraining.objects.all().select_related( 'education_group') if search_form.is_valid(): managers = search_form.get_managers() else: managers = Person.objects.filter( user__groups__name=TRAINING_MANAGERS_GROUP).order_by('last_name') errors = [] if person_training_form.is_valid(): person = person_training_form.cleaned_data['person'] _append_user_to_training_managers(person.user) person_training_form.save() success_msg = _( 'Successfully assigned %(manager)s to the training %(training)s' ) % { "manager": person, "training": person_training_form.cleaned_data['training'].acronym } display_success_messages(request, success_msg) else: errors.append(person_training_form.errors) display_errors(request, errors) for manager in managers: manager.trainings = trainings.filter(managers=manager).distinct() return render( request, "managers.html", { 'managers': get_object_list(request, managers), 'search_form': search_form, 'person_training_form': person_training_form })
def learning_unit_modification_proposal(request, learning_unit_year_id): learning_unit_year = get_object_or_404(LearningUnitYear, id=learning_unit_year_id) user_person = get_object_or_404(Person, user=request.user) initial_data = compute_form_initial_data(learning_unit_year) proposal = proposal_learning_unit.find_by_learning_unit_year( learning_unit_year) form = LearningUnitProposalModificationForm( request.POST or None, initial=initial_data, instance=proposal, learning_unit=learning_unit_year.learning_unit, person=user_person) if form.is_valid(): type_proposal = business_proposal.compute_proposal_type( form.changed_data_for_fields_that_can_be_modified, initial_data.get("type")) form.save(learning_unit_year, type_proposal, compute_proposal_state(user_person)) display_success_messages( request, _("success_modification_proposal").format( _(type_proposal), learning_unit_year.acronym)) return redirect('learning_unit', learning_unit_year_id=learning_unit_year.id) return layout.render( request, 'learning_unit/proposal/create_modification.html', { 'learning_unit_year': learning_unit_year, 'person': user_person, 'form': form, 'experimental_phase': True })
def learning_unit_volumes_management(request, learning_unit_year_id): person = get_object_or_404(Person, user=request.user) context = get_common_context_learning_unit_year(learning_unit_year_id, person) context[ 'learning_units'] = learning_unit_year_with_context.get_with_context( learning_container_year_id=context['learning_unit_year']. learning_container_year_id) volume_edition_formset_container = VolumeEditionFormsetContainer( request, context['learning_units'], person) if volume_edition_formset_container.is_valid() and not request.is_ajax(): try: postponement = int(request.POST.get('postponement', 1)) volume_edition_formset_container.save(postponement) display_success_messages(request, _('success_modification_learning_unit')) return HttpResponseRedirect( reverse(learning_unit_components, args=[learning_unit_year_id])) except IntegrityError: display_error_messages(request, _("error_modification_learning_unit")) context['formsets'] = volume_edition_formset_container.formsets context['tab_active'] = 'components' context['experimental_phase'] = True if request.is_ajax(): return JsonResponse( {'errors': volume_edition_formset_container.errors}) return layout.render(request, "learning_unit/volumes_management.html", context)
def modify_learning_unit(request, learning_unit_year_id): learning_unit_year = get_object_or_404(LearningUnitYear, pk=learning_unit_year_id) person = get_object_or_404(Person, user=request.user) initial_data = compute_learning_unit_modification_form_initial_data( learning_unit_year) form = LearningUnitModificationForm( request.POST or None, learning_unit_year_instance=learning_unit_year, person=person, initial=initial_data) if form.is_valid(): entities_data = form.get_entities_data() lu_type_full_data = form.get_data_for_learning_unit() try: postponement = bool(int(request.POST.get('postponement', 1))) update_learning_unit_year_with_report(learning_unit_year, lu_type_full_data, postponement) update_learning_unit_year_entities_with_report( learning_unit_year, entities_data, postponement) display_success_messages(request, _("success_modification_learning_unit")) return redirect("learning_unit", learning_unit_year_id=learning_unit_year.id) except IntegrityError: display_error_messages(request, _("error_modification_learning_unit")) context = {"learning_unit_year": learning_unit_year, "form": form} return layout.render(request, 'learning_unit/modification.html', context)
def _save_form_and_display_messages(request, form, learning_unit_year): records = None existing_proposal = ProposalLearningUnit.objects.filter( learning_unit_year__learning_unit=learning_unit_year.learning_unit ).order_by('learning_unit_year__academic_year__year') try: records = form.save() display_warning_messages(request, getattr(form, 'warnings', [])) is_postponement = bool(int(request.POST.get('postponement', 0))) if is_postponement and existing_proposal: display_success_messages( request, _('The learning unit has been updated (the report has not been done from %(year)s because the learning ' 'unit is in proposal).') % { 'year': existing_proposal[0].learning_unit_year.academic_year }) elif is_postponement: display_success_messages( request, _('The learning unit has been updated (with report).')) else: display_success_messages( request, _('The learning unit has been updated (without report).')) except ConsistencyError as e: error_list = e.error_list error_list.insert( 0, _('The learning unit has been updated until %(year)s.') % {'year': e.last_instance_updated.academic_year}) display_error_messages(request, e.error_list) return records
def delete(self, request, *args, **kwargs): for education_group_year in delete.get_education_group_years_to_delete( self.get_object()): delete.start(education_group_year) common.display_success_messages(request, self.success_message) return JsonResponse({'success': True, 'success_url': self.success_url})
def _set_success_message(request, is_plural, received_file_state=True): success_msg = "{} {}".format( _('Files are now mark as ') if is_plural else _('File is now mark as '), _('received') if received_file_state else _('not received')) display_success_messages(request, success_msg)
def _show_import_success_message(request, period): display_success_messages( request, _('Internships ratings successfully imported for period %(period)s') % {'period': period})
def toggle_summary_locked(request, learning_unit_year_id): luy = learning_unit_year.toggle_summary_locked(learning_unit_year_id) success_msg = "Update for teacher locked" if luy.summary_locked else "Update for teacher unlocked" display_success_messages(request, success_msg) return redirect(reverse("learning_unit_pedagogy", kwargs={'learning_unit_year_id': learning_unit_year_id}))
def _show_reminder_sent_error_message(request): display_success_messages(request, _('An error occured while sending reminders'))
def show_success_learning_unit_year_creation_message( request, learning_unit_year_created): success_msg = create_learning_unit_year_creation_message( learning_unit_year_created) display_success_messages(request, success_msg, extra_tags='safe')
def _set_success_message(request, is_plural, admission_archived=True): success_msg = "{} {}".format( _('Files are now') if is_plural else _('File is now'), _('archived') if admission_archived else _('unarchived')) display_success_messages(request, success_msg)
def _down(request, group_element_year, *args, **kwargs): success_msg = _("The %(acronym)s has been moved") % { 'acronym': group_element_year.child } group_element_year.down() display_success_messages(request, success_msg)
def _save_and_redirect(request, form, learning_unit_year, success_url): form.save(learning_unit_year=learning_unit_year) display_success_messages(request, "Teaching materials has been updated") return redirect(success_url)
def delete(self, request, *args, **kwargs): result = super().delete(request, *args, **kwargs) common.display_success_messages(request, _(self.success_message)) return result
def _show_reminder_sent_success_message(request): display_success_messages(request, _('Summaries have been sent successfully'))