Produits Entr'ouvert » Chrono

# Generated by Django 2.2.19 on 2021-04-21 13:56

import django.contrib.postgres.fields

from django.db import migrations, models

from dateutil.rrule import DAILY, WEEKLY

def migrate_recurrence_fields(apps, schema_editor):

    Event = apps.get_model('agendas', 'Event')

    for event in Event.objects.filter(recurrence_rule__isnull=False):

        if event.recurrence_rule['freq'] == DAILY:

            event.recurrence_days = list(range(7))

        elif event.recurrence_rule['freq'] == WEEKLY:

            event.recurrence_days = event.recurrence_rule['byweekday']

        event.recurrence_week_interval = event.recurrence_rule.get('interval', 1)

        event.save()

def reverse_migrate_recurrence_fields(apps, schema_editor):

    Event = apps.get_model('agendas', 'Event')

    for event in Event.objects.filter(recurrence_days__isnull=False):

        rrule = {}

        if event.recurrence_days == list(range(7)):

            event.repeat = 'daily'

            rrule['freq'] = DAILY

        else:

            rrule['freq'] = WEEKLY

            rrule['byweekday'] = event.recurrence_days

            if event.recurrence_days == list(range(5)):

                event.repeat = 'weekdays'

            elif event.recurrence_week_interval == 2:

                event.repeat = '2-weeks'

                rrule['interval'] = 2

            else:

                event.repeat = 'weekly'

        event.recurrence_rule = rrule

        event.save()

class Migration(migrations.Migration):

    dependencies = [

        ('agendas', '0078_absence_reasons'),

    ]

    operations = [

        migrations.AddField(

            model_name='event',

            name='recurrence_days',

            field=django.contrib.postgres.fields.ArrayField(

                base_field=models.IntegerField(

                    choices=[(0, 'Mo'), (1, 'Tu'), (2, 'We'), (3, 'Th'), (4, 'Fr'), (5, 'Sa'), (6, 'Su')]

                ),

                blank=True,

                null=True,

                size=None,

                verbose_name='Recurrence days',

            ),

        ),

        migrations.AddField(

            model_name='event',

            name='recurrence_week_interval',

            field=models.IntegerField(

                choices=[(1, 'Every week'), (2, 'Every two weeks'), (3, 'Every three weeks')],

                default=1,

                verbose_name='Repeat',

            ),

        ),

        migrations.RunPython(migrate_recurrence_fields, reverse_migrate_recurrence_fields),

        migrations.RemoveField(

            model_name='event',

            name='recurrence_rule',

        ),

        migrations.RemoveField(

            model_name='event',

            name='repeat',

        ),

    ]

from dateutil.rrule import rrule, rruleset, WEEKLY

            entries = self.event_set.filter(recurrence_days__isnull=True)

            recurring_events = self.event_set.filter(recurrence_days__isnull=False)

    WEEKDAY_CHOICES = [

        (0, _('Mo')),

        (1, _('Tu')),

        (2, _('We')),

        (3, _('Th')),

        (4, _('Fr')),

        (5, _('Sa')),

        (6, _('Su')),

    ]

    INTERVAL_CHOICES = [

        (1, 'Every week'),

        (2, 'Every two weeks'),

        (3, 'Every three weeks'),

    recurrence_days = ArrayField(

        models.IntegerField(choices=WEEKDAY_CHOICES),

        verbose_name=_('Recurrence days'),

        blank=True,

        null=True,

    )

    recurrence_week_interval = models.IntegerField(_('Repeat'), choices=INTERVAL_CHOICES, default=1)

        if self.recurrence_days is not None:

        if event.recurrence_days and event.recurrence_end_date:

            'recurrence_days': self.recurrence_days,

            'recurrence_week_interval': self.recurrence_week_interval,

        days_count = len(self.recurrence_days)

        if days_count == 7:

            repeat = _('Daily')

        elif days_count > 1 and (self.recurrence_days[-1] - self.recurrence_days[0]) == days_count - 1:

            # days are contiguous

            repeat = _('From %(weekday)s to %(last_weekday)s') % {

                'weekday': str(WEEKDAYS[self.recurrence_days[0]]),

                'last_weekday': str(WEEKDAYS[self.recurrence_days[-1]]),

            repeat = _('On %(weekdays)s') % {

                'weekdays': ', '.join([str(WEEKDAYS[i]) for i in self.recurrence_days])

            }

        recurrence_display = _('%(On_day_x)s at %(time)s') % {'On_day_x': repeat, 'time': time}

        if self.recurrence_week_interval > 1:

            if self.recurrence_week_interval == 2:

                every_x_weeks = _('every two weeks')

            elif self.recurrence_week_interval == 3:

                every_x_weeks = _('every three weeks')

            recurrence_display = _('%(Every_x_days)s, once %(every_x_weeks)s') % {

                'Every_x_days': recurrence_display,

                'every_x_weeks': every_x_weeks,

            }

        if self.recurrence_end_date:

            end_date = date_format(self.recurrence_end_date, 'DATE_FORMAT')

            recurrence_display = _('%(Every_x_days)s, until %(date)s') % {

                'Every_x_days': recurrence_display,

                'date': end_date,

            }

        return recurrence_display

    @property

    def recurrence_rule(self):

        recurrence_rule = {

            'freq': WEEKLY,

            'byweekday': self.recurrence_days,

            'interval': self.recurrence_week_interval,

        }

        if self.recurrence_end_date:

            recurrence_rule['until'] = datetime.datetime.combine(

                self.recurrence_end_date, datetime.time(0, 0)

            )

        return recurrence_rule

            recurring_event_queryset = Event.objects.filter(recurrence_days__isnull=False)

from .widgets import SplitDateTimeField, WeekdaysWidget

    frequency = forms.ChoiceField(

        label=_('Event frequency'),

        widget=forms.RadioSelect,

        choices=(

            ('unique', _('Unique')),

            ('recurring', _('Recurring')),

        ),

        initial='unique',

    )

    recurrence_days = forms.TypedMultipleChoiceField(

        choices=Event.WEEKDAY_CHOICES, coerce=int, required=False, widget=WeekdaysWidget

    )

            'frequency',

            'recurrence_days',

            'recurrence_week_interval',

            'recurrence_end_date',

    def clean_recurrence_days(self):

        recurrence_days = self.cleaned_data['recurrence_days']

        if recurrence_days == []:

            return None

        return recurrence_days

class EventForm(NewEventForm):

    protected_fields = (

        'slug',

        'start_datetime',

        'frequency',

        'recurrence_days',

        'recurrence_week_interval',

    )

            'frequency',

            'recurrence_days',

            'recurrence_week_interval',

        self.fields['frequency'].initial = 'recurring' if self.instance.recurrence_days else 'unique'

        if self.instance.recurrence_days and self.instance.has_recurrences_booked():

            for field in (

                'slug',

                'recurrence_end_date',

                'publication_date',

                'frequency',

                'recurrence_days',

                'recurrence_week_interval',

            ):

        if self.cleaned_data.get('frequency') == 'unique':

            self.cleaned_data['recurrence_days'] = None

            self.cleaned_data['recurrence_end_date'] = None

            elif self.instance.recurrence_days:

                    if field != 'frequency' and field not in self.protected_fields

form div.widget[id^=id_recurrence] {

      padding-left: 1em;

}

    {% if not event.recurrence_days %}

{% load i18n gadjo %}

  {{ form|with_template }}

  <script>

    $(function () {

      recurrence_fields = $('[id^=id_recurrence]');

      $('input[type=radio][name=frequency]').change(function() {

        if(!this.checked)

          return;

        if(this.value == 'unique') {

          recurrence_fields.hide();

        } else {

          recurrence_fields.show();

        }

      }).change();

    });

  </script>

{% spaceless %}

<span id="{{ widget.attrs.id }}" class="inputs-buttons-group{% if widget.attrs.class %} {{ widget.attrs.class }}{% endif %}">

	{% for group, options, index in widget.optgroups %}

	{% for option in options %}

	<label{% if option.attrs.id %} for="{{ option.attrs.id }}"{% endif %}>{{ option.label }}</label>

	{% include "django/forms/widgets/input.html" with widget=option %}

	{% endfor %}

	{% endfor %}

</span>

{% endspaceless %}

            queryset = self.agenda.event_set.filter(recurrence_days__isnull=True)

        if self.get_object().recurrence_days:

            or self.object.recurrence_days

from django.forms.widgets import TimeInput, SplitDateTimeWidget, CheckboxSelectMultiple

class WeekdaysWidget(CheckboxSelectMultiple):

    template_name = 'chrono/widgets/weekdays.html'

    def id_for_label(self, id_, index=None):

        """Workaround CheckboxSelectMultiple id_for_label, which would return empty string when

        index is None, leading to more complicated JS from our side."""

        if index is None:

            index = ''

        return super(CheckboxSelectMultiple, self).id_for_label(id_, index)

    recurring_start_datetime = localtime().replace(day=4, month=11, year=2020)

        start_datetime=recurring_start_datetime,

        recurrence_days=[recurring_start_datetime.weekday()],

        label='def',

        start_datetime=start_datetime,

        places=10,

        agenda=agenda,

        recurrence_days=[start_datetime.weekday()],

        label='abc',

        start_datetime=start_datetime,

        places=10,

        agenda=agenda,

        recurrence_days=[start_datetime.weekday()],

        label='def',

        start_datetime=start_datetime,

        places=10,

        agenda=agenda,

        recurrence_days=[start_datetime.weekday()],

    start_datetime = now() - datetime.timedelta(days=3)

        start_datetime=start_datetime,

        recurrence_days=[start_datetime.weekday()],

            or resp.text.count('This field is required.') >= 1

    resp.form['frequency'] = 'recurring'

    resp.form['recurrence_days'] = [localtime().weekday()]

    assert 'On Tuesday at 1:10 p.m.' in resp.text

    resp.form['frequency'] = 'unique'

    assert 'disabled' in resp.form['frequency'].attrs

    assert all('disabled' in resp.form.get('recurrence_days', index=i).attrs for i in range(7))

    assert 'disabled' in resp.form['recurrence_week_interval'].attrs

    assert {

        'slug',

        'frequency',

        'recurrence_days',

        'recurence_weekly_interval',

        'recurrence_end_date',

        'publication_date',

    }.isdisjoint(resp.form.fields)

    event = Event.objects.create(

        start_datetime=now(), places=10, recurrence_days=list(range(7)), agenda=agenda

    )

    event = Event.objects.get(recurrence_days__isnull=False)

    event = Event.objects.create(

        start_datetime=start_datetime, places=10, agenda=agenda, recurrence_days=[start_datetime.weekday()]

    )

        recurrence_days=[now().weekday()],

    different_fields = ['slug', 'recurrence_days', 'recurrence_week_interval']

    event = Event.objects.create(

        agenda=agenda, start_datetime=now(), recurrence_days=[now().weekday()], places=5

    )

def test_recurring_events_repetition(freezer):

        recurrence_days=list(range(7)),  # everyday

    event.recurrence_days = list(range(5))  # from Monday to Friday

    event.recurrence_days = [localtime(event.start_datetime).weekday()]  # from Monday to Friday

    event.recurrence_week_interval = 2

    event.recurrence_days = [3]  # Tuesday but start_datetime is a Wednesday

    event.recurrence_week_interval = 1

    event.save()

    recurrences = event.get_recurrences(localtime(), localtime() + datetime.timedelta(days=10))

    assert len(recurrences) == 2

    # no recurrence exist on Wednesday

    assert all(localtime(r.start_datetime).weekday() == 3 for r in recurrences)

        recurrence_days=list(range(7)),

        agenda=agenda, slug='a', start_datetime=now(), recurrence_days=list(range(7)), places=5

    )

    Event.objects.create(

        agenda=agenda, slug='b', start_datetime=now(), recurrence_days=list(range(7)), duration=10, places=5

    )

    Event.objects.create(

        agenda=agenda, slug='c', start_datetime=now(), recurrence_days=list(range(7)), duration=5, places=5

    )

    Event.objects.create(

        agenda=agenda,

        slug='d',

        start_datetime=now() + datetime.timedelta(hours=1),

        recurrence_days=list(range(7)),

        places=5,

def test_recurring_events_display(freezer):

    freezer.move_to('2021-01-06 12:30')

    agenda = Agenda.objects.create(label='Agenda', kind='events')

    event = Event.objects.create(

        agenda=agenda, start_datetime=now(), recurrence_days=list(range(7)), places=5

    )

    assert event.get_recurrence_display() == 'Daily at 1:30 p.m.'

    event.recurrence_days = [1, 2, 3, 4]

    event.save()

    assert event.get_recurrence_display() == 'From Tuesday to Friday at 1:30 p.m.'

    event.recurrence_days = [4, 5, 6]

    event.save()

    assert event.get_recurrence_display() == 'From Friday to Sunday at 1:30 p.m.'

    event.recurrence_days = [1, 4, 6]

    event.save()

    assert event.get_recurrence_display() == 'On Tuesday, Friday, Sunday at 1:30 p.m.'

    event.recurrence_days = [0]

    event.recurrence_week_interval = 2

    event.save()

    assert event.get_recurrence_display() == 'On Monday at 1:30 p.m., once every two weeks'

    event.recurrence_week_interval = 3

    event.recurrence_end_date = now() + datetime.timedelta(days=7)

    event.save()

    assert (

        event.get_recurrence_display()

        == 'On Monday at 1:30 p.m., once every three weeks, until Jan. 13, 2021'

    )

        recurrence_days=list(range(7)),

    start_datetime = localtime().replace(hour=12, minute=0)

        start_datetime=start_datetime,

        recurrence_days=[start_datetime.weekday()],

    start_datetime = localtime().replace(hour=12, minute=0)

        start_datetime=start_datetime,

        recurrence_days=[start_datetime.weekday()],

        slug='abc',

        label='Test',

        start_datetime=localtime(),

        recurrence_days=[localtime().weekday()],

        places=5,

        agenda=agenda,

        slug='abc',

        start_datetime=localtime(),

        recurrence_days=[localtime().weekday()],

        places=5,

        agenda=agenda,

        recurrence_days=list(range(7)),

        recurrence_week_interval=2,

    assert event.recurrence_days == list(range(7))

    assert event.recurrence_week_interval == 2

    event.recurrence_week_interval = 1