Produits Entr'ouvert » Chrono

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

    url(r'agenda/(?P<agenda_identifier>[\w-]+)/datetimes/$', views.datetimes, name='api-agenda-datetimes'),

        views.fillslot, name='api-fillslot'),

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

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

        name='api-event-status'),

    url(r'agenda/meetings/(?P<meeting_identifier>[\w-]+)/datetimes/$',

                datetime.datetime.combine(parse_date(request.GET['date_end']), datetime.time(0, 0))))

        response = {'data': [{'id': x.id,

                              'text': force_text(x),

                              'datetime': format_response_datetime(x.start_datetime),

                              'description': x.description,

                                      reverse('api-fillslot',

                                          kwargs={

                                              'agenda_identifier': agenda.slug,

                                      })),

                                  'status_url': request.build_absolute_uri(

                                      reverse('api-event-status',

                                          kwargs={

                                              'agenda_identifier': agenda.slug,

                                      }))

                                  },

                              } for x in entries]}

        # create fillslot API URL as a template, to avoid expensive calls

        # to request.build_absolute_uri()

        fillslot_url = request.build_absolute_uri(

                reverse('api-fillslot',

                    kwargs={

                        'agenda_identifier': agenda.slug,

                        }))

        response = {'data': [{'id': x.id,

                              'text': force_text(x),

                              'disabled': bool(x.full),

                              'api': {

                              },

                             } for x in slots]}

        return Response(response)

    permission_classes = (permissions.IsAuthenticated,)

    serializer_class = SlotsSerializer

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

                             format=format)

                        full=False, places=1,

                        desk=available_desk))

        else:

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

        in_waiting_list = False

class Fillslot(Fillslots):

    serializer_class = SlotSerializer

        return self.fillslot(request=request,

                             agenda_identifier=agenda_identifier,

                             format=format)

fillslot = Fillslot.as_view()

class SlotStatus(APIView):

    permission_classes = (permissions.IsAuthenticated,)

        response = {

            'err': 0,

            'places': {

            response['places']['waiting_list_available'] = (event.waiting_list_places - event.waiting_list)

        return Response(response)

slot_status = SlotStatus.as_view()

    agenda = Agenda.objects.get(label=u'Foo bar2')

    resp = app.get('/api/agenda/%s/datetimes/' % agenda.slug)

    for datum in resp.json['data']:

def test_datetimes_api_meetings_agenda(app, meetings_agenda):

    meeting_type = MeetingType.objects.get(agenda=meetings_agenda)

    for agenda_key in (agenda.slug, agenda.id):  # acces datetimes via agenda slug or id (legacy)

        resp_datetimes = app.get('/api/agenda/%s/datetimes/' % agenda_key)

        event_fillslot_url = [x for x in resp_datetimes.json['data'] if x['id'] == event.id][0]['api']['fillslot_url']

    app.authorization = ('Basic', ('john.doe', 'password'))

    resp = app.post('/api/agenda/%s/fillslot/%s/' % (agenda.slug, event.id))

    assert urlparse.urlparse(resp.json['api']['ics_url']).netloc

    assert Booking.objects.count() == 1

    assert Booking.objects.count() == 2

    assert Booking.objects.filter(event__agenda=agenda).count() == 2

def test_booking_api_fillslots(app, some_data, user):

    agenda = Agenda.objects.filter(label=u'Foo bar')[0]

    events_ids = [x.id for x in Event.objects.filter(agenda=agenda) if x.in_bookable_period()]

    assert len(events_ids) == 3

    event = [x for x in Event.objects.filter(agenda=agenda) if x.in_bookable_period()][0]  # first event

    assert bookings[1].primary_booking.id == bookings[0].id == primary_booking_id

    assert bookings[2].primary_booking.id == bookings[0].id == primary_booking_id

    primary_booking_id_2 = resp.json['booking_id']

    assert Booking.objects.count() == 6

    assert Booking.objects.filter(event__agenda=agenda).count() == 6

    assert resp.json['places']['waiting_list_available'] == 4

    assert resp.json['places']['waiting_list_reserved'] == 1

def test_waiting_list_datetimes(app, some_data, user):

    agenda_id = Agenda.objects.filter(label=u'Foo bar')[0].id

    event = Event.objects.filter(agenda_id=agenda_id).exclude(start_datetime__lt=now())[0]

        booking_url = event_data['api']['fillslot_url']

        with CaptureQueriesContext(connection) as ctx:

            app.post(booking_url)

    with CaptureQueriesContext(connection) as ctx:

        app.get('/api/agenda/meetings/%s/datetimes/' % meeting_type.id)