Produits Entr'ouvert » Chrono

    url(r'agenda/(?P<agenda_identifier>[\w-]+)/fillslots/$',

        views.fillslots, name='api-agenda-fillslots'),

    agenda_detail['api']['fillslots_url'] = request.build_absolute_uri(

        reverse('api-agenda-fillslots',

                kwargs={'agenda_identifier': agenda.slug}))

    '''

    payload to fill one slot. The slot (event id) is in the URL.

    '''

class SlotsSerializer(SlotSerializer):

    '''

    payload to fill multiple slots: same as SlotSerializer, but the

    slots list is in the payload.

    '''

    slots = serializers.ListField(

        child=serializers.CharField(max_length=64, allow_blank=False))

class Fillslots(APIView):

    serializer_class = SlotsSerializer

        return self.fillslot(request=request, agenda_identifier=agenda_identifier,

                             format=format)

    def fillslot(self, request, agenda_identifier=None, slots=[], format=None):

        serializer = self.serializer_class(data=request.data)

        payload = serializer.validated_data

        if 'slots' in payload:

            slots = payload['slots']

            if not slots:

                return Response({

                    'err': 1,

                    'reason': 'slots list cannot be empty',

                }, status=status.HTTP_400_BAD_REQUEST)

        if 'count' in payload:

            places_count = payload['count']

        elif 'count' in request.query_params:

            # legacy: count in the query string

                places_count = int(request.query_params['count'])

                    'reason': 'invalid value for count (%r)' % request.query_params['count'],

        else:

            places_count = 1

        extra_data = {}

        for k, v in request.data.items():

            if k not in serializer.validated_data:

                extra_data[k] = v

            # slots are actually timeslot ids (meeting_type:start_datetime), not events ids.

            # split them back to get both parts

            meeting_type_id = slots[0].split(':')[0]

            datetimes = set()

            for slot in slots:

                meeting_type_id_, datetime_str = slot.split(':')

                if meeting_type_id_ != meeting_type_id:

                    return Response({

                        'err': 1,

                        'reason': 'all slots must have the same meeting type id (%s)' % meeting_type_id

                    })

                datetimes.add(make_aware(datetime.datetime.strptime(datetime_str, '%Y-%m-%d-%H%M')))

            # get all free slots and separate them by desk

            all_slots = get_all_slots(agenda, MeetingType.objects.get(id=meeting_type_id))

            all_slots = [slot for slot in all_slots if not slot.full]

            datetimes_by_desk = defaultdict(set)

            for slot in all_slots:

                datetimes_by_desk[slot.desk.id].add(slot.start_datetime)

            # search first desk where all requested slots are free

            for available_desk_id in datetimes_by_desk:

                if datetimes.issubset(datetimes_by_desk[available_desk_id]):

                    available_desk = Desk.objects.get(id=available_desk_id)

                    break

            else:

            # all datetimes are free, book them in order

            datetimes = list(datetimes)

            datetimes.sort()

            # booking requires real Event objects (not lazy Timeslots);

            # create them now, with data from the slots and the desk we found.

            events = []

            for start_datetime in datetimes:

                events.append(Event.objects.create(agenda=agenda,

                        meeting_type_id=meeting_type_id,

                        start_datetime=start_datetime,

                        full=False, places=1,

                        desk=available_desk))

        else:

            events = Event.objects.filter(id__in=slots).order_by('start_datetime')

        # search free places. Switch to waiting list if necessary.

        in_waiting_list = False

        for event in events:

            if event.waiting_list_places:

                if (event.booked_places + places_count) > event.places or event.waiting_list:

                    # if this is full or there are people waiting, put new bookings

                    # in the waiting list.

                    in_waiting_list = True

                    if (event.waiting_list + places_count) > event.waiting_list_places:

                        return Response({'err': 1, 'reason': 'sold out'})

            else:

                if (event.booked_places + places_count) > event.places:

        # now we have a list of events, try to book them.

        primary_booking = None

        for event in events:

            for i in range(places_count):

                new_booking = Booking(event_id=event.id,

                                      in_waiting_list=in_waiting_list,

                                      label=payload.get('label', ''),

                                      user_name=payload.get('user_name', ''),

                                      backoffice_url=payload.get('backoffice_url', ''),

                                      extra_data=extra_data)

                if primary_booking is not None:

                    new_booking.primary_booking = primary_booking

                new_booking.save()

                if primary_booking is None:

                    primary_booking = new_booking

            'in_waiting_list': in_waiting_list,

            'booking_id': primary_booking.id,

            'datetime': localtime(events[0].start_datetime),

                    reverse('api-cancel-booking', kwargs={'booking_pk': primary_booking.id}))

        if in_waiting_list:

                    reverse('api-accept-booking', kwargs={'booking_pk': primary_booking.id}))

            response['end_datetime'] = localtime(events[-1].end_datetime)

fillslots = Fillslots.as_view()

class Fillslot(Fillslots):

    serializer_class = SlotSerializer

    def post(self, request, agenda_identifier=None, event_pk=None, format=None):

        return self.fillslot(request=request,

                             agenda_identifier=agenda_identifier,

                             slots=[event_pk],  # fill a "list on one slot"

                             format=format)

         'api': {'datetimes_url': 'http://testserver/api/agenda/%s/datetimes/' % agenda1.slug,

                 'fillslots_url': 'http://testserver/api/agenda/%s/fillslots/' % agenda1.slug}},

                 'fillslots_url': 'http://testserver/api/agenda/%s/fillslots/' % meetings_agenda.slug,

         'api': {'datetimes_url': 'http://testserver/api/agenda/%s/datetimes/' % agenda2.slug,

                 'fillslots_url': 'http://testserver/api/agenda/%s/fillslots/' % agenda2.slug}}