Produits Entr'ouvert » Chrono

                self.default_view = 'month'

            else:

                self.default_view = 'day'

    @property

    def base_slug(self):

    def save(self, *args, **kwargs):

        if self.agenda:

            assert self.agenda.kind == 'virtual', "a time period can only reference a virtual agenda"

    @property

    def weekday_str(self):

        assert self.agenda.kind != 'virtual', "a meetingtype can't reference a virtual agenda"

        if not self.slug:

            self.slug = generate_slug(self, agenda=self.agenda)

    @property

    def base_slug(self):

        self.check_full()

        if not self.slug:

            self.slug = generate_slug(self, seen_slugs=seen_slugs, agenda=self.agenda)

    @property

    def base_slug(self):

    def save(self, *args, **kwargs):

        with transaction.atomic():

            initial_values = self.event.full, self.event.almost_full

            self.event.check_full()

            if (self.event.full, self.event.almost_full) != initial_values:

        assert self.agenda.kind != 'virtual', "a desk can't reference a virtual agenda"

        if not self.slug:

            self.slug = generate_slug(self, agenda=self.agenda)

    @property

    def base_slug(self):

    def save(self, *args, **kwargs):

        if not self.slug:

            self.slug = generate_slug(self)

    def can_be_managed(self, user):

        if user.is_staff:

        # add reason for compatibility (https://dev.entrouvert.org/issues/24025)

        if data is not None and 'err_class' in data:

            data['reason'] = data['err_class']

class APIError(Exception):

    def __init__(self, *args, **kwargs):

        self.__dict__.update(kwargs)

    def to_response(self):

        data = {

    def to_internal_value(self, data):

        if isinstance(data, str):

            data = [s.strip() for s in data.split(',')]

class SlotsSerializer(SlotSerializer):

        ]

    def __init__(self, *args, **kwargs):

        if kwargs['instance'].kind != 'events':

            del self.fields['booking_form_url']

            del self.fields['event_display_template']

        ]

    def __init__(self, *args, **kwargs):

        if kwargs['instance'].kind != 'virtual':

            self.fields['minimal_booking_delay'].required = True

            self.fields['maximal_booking_delay'].required = True

        fields = ['real_agenda']

    def __init__(self, *args, **kwargs):

        self.fields['real_agenda'].queryset = Agenda.objects.filter(kind='meetings').exclude(

            virtual_agendas=self.instance.virtual_agenda

        )

    def __init__(self, agenda_pk, **kwargs):

        self.agenda_pk = agenda_pk

    def clean_events_csv_file(self):

        content = self.cleaned_data['events_csv_file'].read()

    model = Agenda

    def get_queryset(self):

        if not self.request.user.is_staff:

            group_ids = [x.id for x in self.request.user.groups.all()]

            queryset = queryset.filter(Q(view_role_id__in=group_ids) | Q(edit_role_id__in=group_ids))

    def dispatch(self, request, *args, **kwargs):

        if not request.user.is_staff:

            raise PermissionDenied()

    def get_success_url(self):

        return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.object.id})

    def dispatch(self, request, *args, **kwargs):

        if not request.user.is_staff:

            raise PermissionDenied()

    def form_valid(self, form):

        try:

        if global_noop:

            messages.info(self.request, _('No data found.'))

agendas_import = AgendasImportView.as_view()

        self.set_agenda(**kwargs)

        if not self.check_permissions(request.user):

            raise PermissionDenied()

    def check_permissions(self, user):

        return self.agenda.can_be_viewed(user)

    def get_context_data(self, **kwargs):

        context['agenda'] = self.agenda

        return context

    def dispatch(self, request, *args, **kwargs):

        if not request.user.is_staff:

            raise PermissionDenied()

    def get_context_data(self, **kwargs):

        context['cannot_delete'] = Booking.objects.filter(

            event__agenda=self.get_object(),

            event__start_datetime__gt=now(),

        context = self.get_context_data()

        if context['cannot_delete']:

            raise PermissionDenied()

agenda_delete = AgendaDeleteView.as_view()

                    kwargs={'pk': kwargs['pk'], 'year': date.year, 'month': date.month, 'day': date.day},

                )

            )

    def get_context_data(self, **kwargs):

        context['agenda'] = self.agenda

        if self.agenda.kind != 'events':

            try:

class AgendaMonthView(AgendaDateView, MonthArchiveView):

    def get_queryset(self):

        if self.agenda.kind != 'events':

            return qs

        return Event.annotate_queryset(qs).order_by('start_datetime', 'label')

        return ['chrono/manager_%s_agenda_month_view.html' % self.agenda.kind]

    def get_context_data(self, **kwargs):

        if self.agenda.kind == 'events':

            context['cancellation_reports'] = EventCancellationReport.objects.filter(

                event__agenda=self.agenda,

        self.agenda = self.get_object().agenda

        if not self.agenda.can_be_managed(request.user):

            raise PermissionDenied()

    def get_context_data(self, **kwargs):

        context['agenda'] = self.object.agenda

        return context

            raise Http404()

        if not self.desk.agenda.can_be_managed(request.user):

            raise PermissionDenied()

    def get_form_kwargs(self):

        kwargs = super().get_form_kwargs()

        return kwargs

    def get_context_data(self, **kwargs):

        context['desk'] = self.desk

        context['agenda'] = self.desk.agenda

        return context

        self.desk = self.get_object().desk

        if not self.desk.agenda.can_be_managed(request.user):

            raise PermissionDenied()

    def get_context_data(self, **kwargs):

        context['desk'] = self.object.desk

        context['agenda'] = self.object.desk.agenda

        return context

        if not self.agenda.can_be_managed(request.user):

            raise PermissionDenied()

    def get_context_data(self, **kwargs):

        context['agenda'] = self.agenda

        return context

        return self.agenda

    def get_context_data(self, **kwargs):

        if self.agenda.accept_meetings():

            context['meeting_types'] = self.object.iter_meetingtypes()

        if self.agenda.kind == 'virtual':

    content_type = 'text/csv'

    def get_context_data(self, **kwargs):

        some_future_date = datetime.datetime.now() + datetime.timedelta(days=10)

        some_future_date = some_future_date.replace(hour=14, minute=0, second=0)

        context['some_future_date'] = some_future_date

                    _('Event "%s" start date has changed. Do not forget to notify the registrants.')

                    % (event.label or event.slug),

                )

agenda_import_events = AgendaImportEventsView.as_view()

        return ['chrono/manager_event_detail.html']

    def get_context_data(self, **kwargs):

        context['user_can_manage'] = self.agenda.can_be_managed(self.request.user)

        event = self.get_object()

        context['booked'] = event.booking_set.filter(

    pk_url_kwarg = 'event_pk'

    def get_context_data(self, **kwargs):

        context['cannot_delete'] = bool(

            self.object.booking_set.filter(cancellation_datetime__isnull=True).exists()

            and self.object.start_datetime > now()

        context = self.get_context_data()

        if context['cannot_delete']:

            raise PermissionDenied()

    def get_success_url(self):

        if self.request.GET.get('next') == 'settings' or self.request.POST.get('next') == 'settings':

    model = MeetingType

    def get_context_data(self, **kwargs):

        meeting_type = self.get_object()

        context['cannot_delete'] = False

                process_time_period_add_form(form, desk=desk)

        else:

            process_time_period_add_form(form, desk=self.desk)

agenda_add_time_period = AgendaAddTimePeriodView.as_view()

    def form_valid(self, form):

        process_time_period_add_form(form, agenda=self.agenda)

virtual_agenda_add_time_period = VirtualAgendaAddTimePeriodView.as_view()

        return super().get_queryset().filter(agenda__kind='meetings')

    def get_context_data(self, **kwargs):

        context['cannot_delete'] = Booking.objects.filter(

            event__desk=self.get_object(), event__start_datetime__gt=now(), cancellation_datetime__isnull=True

        ).exists()

        context = self.get_context_data()

        if context['cannot_delete']:

            raise PermissionDenied()

desk_delete = DeskDeleteView.as_view()

        self.agenda = self.get_object().virtual_agenda

        if not self.agenda.can_be_managed(request.user):

            raise PermissionDenied()

    def get_context_data(self, **kwargs):

        context['agenda'] = self.agenda

        return context

        )

    def get_context_data(self, **kwargs):

        context['user_can_manage'] = self.desk.agenda.can_be_managed(self.request.user)

        return context

    def get_queryset(self):

        # but limit queryset

time_period_exception_extract_list = TimePeriodExceptionExtractListView.as_view()

            if success_url in referer:

                return success_url

        if self.desk and 'from_popup' in self.request.GET:

            success_url = '{}?display_exceptions={}'.format(success_url, self.desk.pk)

        return success_url

    template_name = 'chrono/manager_import_exceptions.html'

    def get_context_data(self, **kwargs):

        desk = self.get_object()

        context['exception_sources'] = desk.timeperiodexceptionsource_set.all()

        context['desk'] = desk

            return self.form_invalid(form)

        messages.info(self.request, _('Exceptions will be imported in a few minutes.'))

desk_import_time_period_exceptions = DeskImportTimePeriodExceptionsView.as_view()

    template_name = 'chrono/manager_replace_exceptions.html'

    def get_queryset(self):

        return queryset.filter(ics_filename__isnull=False)

    def import_file(self, desk, form):

            return self.form_invalid(form)

        messages.info(self.request, _('Exceptions will be synchronized in a few minutes.'))

time_period_exception_source_replace = TimePeriodExceptionSourceReplaceView.as_view()

    model = TimePeriodExceptionSource

    def get_queryset(self):

        return queryset.filter(ics_url__isnull=False)

    def import_file(self, desk):

    model = UnavailabilityCalendar

    def get_context_data(self, **kwargs):

        context['unavailability_calendar'] = self.object

        return context

        return kwargs

    def get_context_data(self, **kwargs):

        context['base_template'] = 'chrono/manager_unavailability_calendar_settings.html'

        context['cancel_url'] = reverse(

            'chrono-manager-unavailability-calendar-settings', kwargs={'pk': self.unavailability_calendar.pk}

    input_type = 'time'

    def __init__(self, **kwargs):

        self.attrs['step'] = '300'  # 5 minutes

        self.attrs['pattern'] = '[0-9]{2}:[0-9]{2}'

class DecoratedURLPattern(URLPattern):

    def resolve(self, *args, **kwargs):

        if result:

            result.func = self._decorate_with(result.func)

        return result

        kwargs['timeout'] = kwargs.get('timeout') or settings.REQUESTS_TIMEOUT

        if log_errors and (response.status_code // 100 != 2):

            extra = {}

            if django_request:

            return HttpResponseRedirect(

                resolve_url('mellon_login') + '?next=' + quote(request.GET.get('next'))

            )

class LogoutView(auth_views.LogoutView):

    def dispatch(self, request, *args, **kwargs):

        if any(get_idps()):

            return HttpResponseRedirect(resolve_url('mellon_logout'))

def homepage(request, *args, **kwargs):