0002-agendas-factorize-recurrent-event-update-code-57305.patch

Nicolas Roche, 30 septembre 2021 18:39

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

Subject: [PATCH 2/2] agendas: factorize recurrent event update code (#57305)

 chrono/agendas/models.py | 23 +++++++++++++++++++++++
 chrono/api/views.py      | 15 ++-------------
 chrono/manager/forms.py  | 24 +++++++-----------------
 3 files changed, 32 insertions(+), 30 deletions(-)

         def save(self, seen_slugs=None, *args, **kwargs):
             assert self.agenda.kind != 'virtual', "an event can't reference a virtual agenda"
             assert not (self.slug and self.slug.isdigit()), 'slug cannot be a number'
             self.start_datetime = self.start_datetime.replace(second=0, microsecond=0)
             if not self.slug:
                 self.slug = generate_slug(self, seen_slugs=seen_slugs, agenda=self.agenda)
             return super().save(*args, **kwargs)
         def pre_update(
             self, changed_data=None, cleaned_data=None, protected_fields=None, more_protected_fields=None
         ):
             changed_data = changed_data or []
             cleaned_data = cleaned_data or {}
             protected_fields = protected_fields or []
             more_protected_fields = more_protected_fields or []
             if any(field for field in changed_data if field in protected_fields):
                 self.recurrences.all().delete()
             elif self.recurrence_days:
                 protected_fields = list(protected_fields) + more_protected_fields
                 update_fields = {
                     field: value for field, value in cleaned_data.items() if field not in protected_fields
+                }
                 self.recurrences.update(**update_fields)
         def post_update(self):
             if self.recurrence_end_date:
                 self.recurrences.filter(start_datetime__gt=self.recurrence_end_date).delete()
                 excluded_datetimes = [evt.datetime_slug for evt in self.recurrences.all()]
                 self.create_all_recurrences(excluded_datetimes)
         @property
         def base_slug(self):
             # label can be empty
             return slugify(self.label or ('%s-event' % self.agenda.label))
         def main_list_full(self):
             return bool(self.booked_places >= self.places)

                     raise APIError(
                         _('invalid payload'),
                         err_class='invalid payload',
                         errors=errors,
                         http_status=status.HTTP_400_BAD_REQUEST,
+                    )
             with transaction.atomic():
                 if any(field for field in changed_data if field in protected_fields):
                     event.recurrences.all().delete()
                 elif event.recurrence_days:
                     protected_fields.append('recurrence_end_date')
                     update_fields = {
                         field: value for field, value in payload.items() if field not in protected_fields
+                    }
                     event.recurrences.update(**update_fields)
                 event.pre_update(changed_data, payload, protected_fields, ['recurrence_end_date'])
                 event = serializer.save()
                 if event.recurrence_end_date:
                     event.recurrences.filter(start_datetime__gt=event.recurrence_end_date).delete()
                     excluded_datetimes = [evt.datetime_slug for evt in event.recurrences.all()]
                     event.create_all_recurrences(excluded_datetimes)
                 event.post_update()
             return Response({'err': 0, 'data': get_event_detail(request, event)})
     events = Events.as_view()
     class EventStatus(APIView):

                 raise ValidationError(_('Bookings exist after this date.'))
             if self.cleaned_data.get('frequency') == 'unique':
                 self.cleaned_data['recurrence_days'] = None
                 self.cleaned_data['recurrence_end_date'] = None
         def save(self, *args, **kwargs):
             with transaction.atomic():
                 if any(field for field in self.changed_data if field in self.protected_fields):
                     self.instance.recurrences.all().delete()
                 elif self.instance.recurrence_days:
                     protected_fields = list(self.protected_fields) + ['recurrence_end_date', 'frequency']
                     update_fields = {
                         field: value
                         for field, value in self.cleaned_data.items()
                         if field not in protected_fields
+                    }
                     self.instance.recurrences.update(**update_fields)
                 self.instance.pre_update(
                     self.changed_data,
                     self.cleaned_data,
                     self.protected_fields,
                     ['recurrence_end_date', 'frequency'],
+                )
                 super().save(*args, **kwargs)
                 if self.instance.recurrence_end_date:
                     self.instance.recurrences.filter(
                         start_datetime__gt=self.instance.recurrence_end_date
                     ).delete()
                     excluded_datetimes = [event.datetime_slug for event in self.instance.recurrences.all()]
                     self.instance.create_all_recurrences(excluded_datetimes)
                 self.instance.post_update()
             return self.instance
     class BookingCheckFilterSet(django_filters.FilterSet):
         class Meta:
             model = Booking
             fields = []
+    -

Projet

Général

Profil

Produits Entr'ouvert » Chrono

0002-agendas-factorize-recurrent-event-update-code-57305.patch