0001-manager-configuer-user-block-on-check-page-53237.patch

Lauréline Guérin, 20 avril 2021 09:59

Voir les différences: en ligne côte à côte

Subject: [PATCH] manager: configuer user block on check page (#53237)

 .../0079_booking_user_block_template.py       | 23 +++++++++++
 chrono/agendas/models.py                      | 24 ++++++++++++
 chrono/manager/forms.py                       | 16 +++++++-
 .../templates/chrono/manager_event_check.html | 16 ++++----
 .../manager_event_check_booking_fragment.html |  2 +-
 .../manager_events_agenda_settings.html       | 31 ++++++++-------
 chrono/manager/urls.py                        |  6 +--
 chrono/manager/views.py                       | 13 ++++---
 tests/manager/test_absence_reason.py          |  7 ++--
 tests/manager/test_all.py                     | 38 ++++++++++++++++++-
 tests/manager/test_event.py                   |  6 +++
 11 files changed, 146 insertions(+), 36 deletions(-)
 create mode 100644 chrono/agendas/migrations/0079_booking_user_block_template.py

     from django.db import migrations, models
     import chrono.agendas.models
     class Migration(migrations.Migration):
         dependencies = [
             ('agendas', '0078_absence_reasons'),
+        ]
         operations = [
             migrations.AddField(
                 model_name='agenda',
                 name='booking_user_block_template',
                 field=models.TextField(
                     blank=True,
                     help_text='Displayed for each booking in event check page',
                     verbose_name='User block template',
                     validators=[chrono.agendas.models.django_template_validator],
                 ),
             ),
+        ]

             _('Booking form URL'), max_length=200, blank=True, validators=[django_template_validator]
+        )
         desk_simple_management = models.BooleanField(default=False)
         booking_user_block_template = models.TextField(
             _('User block template'),
             help_text=_('Displayed for each booking in event check page'),
             blank=True,
             validators=[django_template_validator],
+        )
         class Meta:
             ordering = ['label']
-...
             except (VariableDoesNotExist, TemplateSyntaxError):
                 return
         def get_booking_user_block_template(self):
             return (
                 self.booking_user_block_template
                 or '{{ booking.user_name|default:booking.label|default:"%s" }}' % _('Unknown')
+            )
         def prefetch_desks_and_exceptions(self, with_sources=False):
             if self.kind == 'meetings':
                 desks = self.desk_set.all()
-...
                 self.secondary_booking_set.update(in_waiting_list=True)
                 self.save()
         def get_user_block(self):
             template_vars = Context(settings.TEMPLATE_VARS)
             template_vars.update(
+                {
                     'booking': self,
+                }
+            )
             try:
                 return Template(self.event.agenda.get_booking_user_block_template()).render(template_vars)
             except (VariableDoesNotExist, TemplateSyntaxError):
                 return
         @classmethod
         def anonymize_bookings(cls, bookings_queryset):
             bookings_queryset.update(

     from django.forms import ValidationError
     from django.utils.encoding import force_text
     from django.utils.six import StringIO
     from django.utils.timezone import make_aware, make_naive, now
     from django.utils.timezone import make_aware, now
     from django.utils.translation import ugettext_lazy as _
     from chrono.agendas.models import (
         WEEKDAYS_LIST,
         AbsenceReason,
         AbsenceReasonGroup,
         Agenda,
         AgendaNotificationsSettings,
         AgendaReminderSettings,
-...
             fields = []
     class AgendaBookingCheckSettingsForm(forms.ModelForm):
         class Meta:
             model = Agenda
             fields = ['absence_reasons_group', 'booking_user_block_template']
             widgets = {'booking_user_block_template': forms.Textarea(attrs={'rows': 3})}
         def __init__(self, *args, **kwargs):
             super().__init__(*args, **kwargs)
             if not AbsenceReasonGroup.objects.exists():
                 del self.fields['absence_reasons_group']
     class AgendaNotificationsForm(forms.ModelForm):
         class Meta:
             model = AgendaNotificationsSettings

       <h3>
         {% blocktrans with places=object.waiting_list_places booked_places=waiting|length %}Waiting List ({{ booked_places }}/{{ places }}){% endblocktrans %}
       </h3>
     <div>
       <ul class="objects-list single-links">
         {% for booking in waiting %}
         <li><a>{{ booking.user_name|default:booking.label|default:_('Unknown') }}</a></li>
         {% endfor %}
       </ul>
     </div>
       <div>
         <table class="main check-bookings">
           <tbody>
             {% for booking in waiting %}
             <tr><td class="booking-username">{{ booking.get_user_block }}</td></tr>
             {% endfor %}
           </tbody>
         </table>
       </div>
     </div>
     {% endif %}
     {% endblock %}

chrono/manager/templates/chrono/manager_event_check_booking_fragment.html
1	1	{% load i18n %}
2	2
3		<td class="booking-username">{{ booking.user_name\|default:booking.label\|default:_('Unknown') }}</td>
	3	<td class="booking-username">{{ booking.get_user_block }}</td>
4	4	<td class="booking-status">
5	5	{{ booking.user_was_present\|yesno:_('Present,Absent,-') }}
6	6	{% if booking.user_was_present is False and booking.user_absence_reason %}

     </div>
     </div>
     {% if has_absence_reasons %}
     <div class="section">
     <h3>{% trans "Absence reasons" %}
     <a rel="popup" class="button" href="{% url 'chrono-manager-agenda-absence-reasons' pk=object.id %}">{% trans 'Configure' %}</a>
     <h3>{% trans "Booking check options" %}
         <a rel="popup" class="button" href="{% url 'chrono-manager-agenda-booking-check-settings' pk=object.pk %}">{% trans 'Configure' %}</a>
     </h3>
     <div>
     {% if agenda.absence_reasons_group %}
     <p>{% trans "Absence reasons group:" %} {{ agenda.absence_reasons_group }}</p>
     <ul>
       {% for reason in agenda.absence_reasons_group.absence_reasons.all %}
       <li>{{ reason }}</li>
       {% endfor %}
     </ul>
     {% else %}
     <p>{% trans "No absence reasons configured for this agenda." %}</p>
     {% endif %}
         {% if has_absence_reasons %}
             {% if agenda.absence_reasons_group %}
             <p>{% trans "Absence reasons group:" %} {{ agenda.absence_reasons_group }}</p>
             <ul>
               {% for reason in agenda.absence_reasons_group.absence_reasons.all %}
               <li>{{ reason }}</li>
               {% endfor %}
             </ul>
             {% else %}
             <p>{% trans "No absence reasons configured for this agenda." %}</p>
             {% endif %}
         {% endif %}
         <p>{% trans "User block template" %}:</p>
         <pre>{{ agenda.get_booking_user_block_template }}</pre>
     </div>
     </div>
     {% endif %}
     <div class="section">
     <h3>{% trans "Notifications" %}

         ),
         url(r'^agendas/(?P<pk>\d+)/roles$', views.agenda_roles, name='chrono-manager-agenda-roles'),
         url(
             r'^agendas/(?P<pk>\d+)/absence-reasons$',
             views.agenda_absence_reasons,
             name='chrono-manager-agenda-absence-reasons',
             r'^agendas/(?P<pk>\d+)/check-options$',
             views.agenda_booking_check_settings,
             name='chrono-manager-agenda-booking-check-settings',
         ),
         url(r'^agendas/(?P<pk>\d+)/delete$', views.agenda_delete, name='chrono-manager-agenda-delete'),
         url(r'^agendas/(?P<pk>\d+)/export$', views.agenda_export, name='chrono-manager-agenda-export'),

     from .forms import (
         AgendaAddForm,
         AgendaBookingCheckSettingsForm,
         AgendaBookingDelaysForm,
         AgendaDuplicateForm,
         AgendaEditForm,
-...
     agenda_roles = AgendaRolesView.as_view()
     class AgendaAbsenceReasonsView(AgendaEditView):
         form_class = None
         fields = ['absence_reasons_group']
         title = _('Configure absence reasons')
     class AgendaBookingCheckSettingsView(AgendaEditView):
         form_class = AgendaBookingCheckSettingsForm
         title = _("Configure booking check options")
         def set_agenda(self, **kwargs):
             self.agenda = get_object_or_404(Agenda, pk=kwargs.get('pk'), kind='events')
         def get_initial(self):
             return {'booking_user_block_template': self.agenda.get_booking_user_block_template()}
     agenda_absence_reasons = AgendaAbsenceReasonsView.as_view()
     agenda_booking_check_settings = AgendaBookingCheckSettingsView.as_view()
     class AgendaDeleteView(DeleteView):

         resp = app.get('/manage/agendas/%s/settings' % agenda.pk)
         assert 'has_absence_reasons' in resp.context
         assert resp.context['has_absence_reasons'] is False
         assert 'Absence reasons' not in resp
         assert 'No absence reasons configured for this agenda.' not in resp
         assert '/manage/agendas/%s/absence-reasons' % agenda.pk not in resp
         resp = resp.click(href='/manage/agendas/%s/check-options' % agenda.pk)
         assert 'absence_reasons_group' not in resp.context['form'].fields
         group = AbsenceReasonGroup.objects.create(label='Foo bar')
         resp = app.get('/manage/agendas/%s/settings' % agenda.pk)
         assert 'has_absence_reasons' in resp.context
         assert resp.context['has_absence_reasons'] is True
         assert 'Absence reasons' in resp
         assert 'No absence reasons configured for this agenda.' in resp
         resp = resp.click(href='/manage/agendas/%s/absence-reasons' % agenda.pk)
         resp = resp.click(href='/manage/agendas/%s/check-options' % agenda.pk)
         resp.form['absence_reasons_group'] = group.pk
         resp = resp.form.submit().follow()
         assert 'Absence reasons group: Foo bar' in resp

         assert agenda.minimal_booking_delay == 1
     def test_options_virtuale_agenda_can_unset_delays(app, admin_user):
     def test_options_virtual_agenda_can_unset_delays(app, admin_user):
         agenda = Agenda.objects.create(label=u'Foo bar', kind='virtual', maximal_booking_delay=2)
         assert agenda.maximal_booking_delay == 2
         app = login(app)
-...
         assert agenda.maximal_booking_delay is None
     def test_options_agenda_booking_user_block_template(app, admin_user):
         agenda = Agenda.objects.create(label='Foo bar', kind='events')
         assert agenda.booking_user_block_template == ''
         assert (
             agenda.get_booking_user_block_template()
             == '{{ booking.user_name|default:booking.label|default:"Unknown" }}'
+        )
         app = login(app)
         url = '/manage/agendas/%s/check-options' % agenda.pk
         resp = app.get(url)
         resp.form['booking_user_block_template'] = '{{ booking.user_name }} Foo Bar'
         resp = resp.form.submit()
         agenda.refresh_from_db()
         assert agenda.booking_user_block_template == '{{ booking.user_name }} Foo Bar'
         assert agenda.get_booking_user_block_template() == '{{ booking.user_name }} Foo Bar'
         resp = app.get(url)
         resp.form['booking_user_block_template'] = ''
         resp = resp.form.submit()
         agenda.refresh_from_db()
         assert agenda.booking_user_block_template == ''
         assert (
             agenda.get_booking_user_block_template()
             == '{{ booking.user_name|default:booking.label|default:"Unknown" }}'
+        )
         # check kind
         agenda.kind = 'meetings'
         agenda.save()
         app.get(url, status=404)
         agenda.kind = 'virtual'
         agenda.save()
         app.get(url, status=404)
     def test_options_agenda_as_manager(app, manager_user):
         agenda = Agenda(label=u'Foo bar')
         agenda.view_role = manager_user.groups.all()[0]

         )  # user ordering is not optimal ...
         assert 'User Cancelled' not in resp
         agenda.booking_user_block_template = '{{ booking.user_name }} Foo Bar'
         agenda.save()
         resp = app.get('/manage/agendas/%s/events/%s/check' % (agenda.pk, event.pk))
         assert 'User 1 Foo Bar' in resp
         assert 'User Waiting Foo Bar' in resp
         # cancelled booking
         token = resp.context['csrf_token']
         app.post(
+    -

Projet

Général

Profil

Produits Entr'ouvert » Chrono

0001-manager-configuer-user-block-on-check-page-53237.patch