Python forms.EventForm类代码示例

def edit_event_view(request, event_pk):
    ''' The view to edit an event. '''
    page_name = "Edit Event"
    profile = UserProfile.objects.get(user=request.user)
    event = get_object_or_404(Event, pk=event_pk)
    if event.owner != profile and not request.user.is_superuser:
        return HttpResponseRedirect(
            reverse('events:view', kwargs={"event_pk": event_pk}),
            )
    event_form = EventForm(
        request.POST or None,
        profile=profile,
        instance=event,
        )
    if event_form.is_valid():
        event = event_form.save()
        messages.add_message(
            request, messages.SUCCESS,
            MESSAGES['EVENT_UPDATED'].format(event=event.title),
            )
        return HttpResponseRedirect(
            reverse('events:view', kwargs={"event_pk": event_pk}),
            )
    return render_to_response('edit_event.html', {
        'page_name': page_name,
        'event_form': event_form,
        }, context_instance=RequestContext(request))

    def post(self, request):
        # Temporary part of the method to create tickets for test purposes
        if 'test_baseticket' in request.POST:
            response = create_test_baseticket()
            return response

        event_form = EventForm(request.POST)
        base_ticket_price_form = BaseTicketPriceForm(request.POST)
        upload_form = UploadBaseTicketNew(request.POST, request.FILES)

        if not(event_form.is_valid() and base_ticket_price_form.is_valid() and upload_form.is_valid()):
            return render(request, self.template_name,
                              {'upload_form': upload_form, 'event_form': event_form,
                               'base_ticket_price_form': base_ticket_price_form, 'pdf_exists': 'false'})

        # if the forms were valid
        pdf_file = request.FILES['pdf_file']
        price = request.POST.get('price')

        pdf_object = ProcessBaseTicket(pdf_file)

        if not pdf_object.successful:
            messages.add_message(request, messages.ERROR, pdf_object.message)
            return render(request, self.template_name,
                              {'upload_form': upload_form, 'event_form': event_form,
                               'base_ticket_price_form': base_ticket_price_form, 'pdf_exists': 'false'})

        event = event_form.save()
        self.create_base_ticket(pdf_object, event, price)

        messages.add_message(request, messages.SUCCESS, message_text.event_creation_successful)
        return redirect('buy_ticket:available_tickets', event.id)

def create(request):
    form = EventForm(request.POST or None)
    if form.is_valid():
        event = form.save(commit=False)
        event.creator = request.user
        g_d = None
        for  word in event.description.split():
            try:
                g_d = parse(word, fuzzy=True)
                break
            except :
                continue
        event.start_date = g_d
        event.save()

        #request.user.message_set.create(message="Event posted successfully.")

        if 'next' in request.POST:
            next = request.POST['next']
        else:
            next = reverse('ev_tonight')

        return HttpResponseRedirect(next)
    else:
        return render_to_response(
            'event/create.html',
            {'form':form},
            context_instance = RequestContext(request)
        )

def add(request, app_label, model_name, id):
    ''' Tag an event to another model object '''

    try:
        ct = ContentType.objects.get(\
                app_label = app_label,
                model = model_name)
        obj = ct.get_object_for_this_type( id=id )

    except:
        return HttpResponseNotFound()

    if request.method == 'POST':
        #request.POST.update( { 'owner':request.user.id, 'object_id':id,
        #        'content_type':ct.id, 'content_obj': obj, } )
        form = EventForm(request.POST)

        if form.is_valid():
            ev = form.save(commit=False)
            ev.owner = request.user
            ev.object_id = obj.id
            ev.content_type = ct
            ev.save()


            return HttpResponseRedirect(ev.get_absolute_url())

    else:
        form = EventForm()

    context = { 'form':form, 'object':obj, 'content_type':ct, }
    context.update(locals())

    return render_to_response('events/events_add.html', context,\
            context_instance = RequestContext(request))

def create(request):
	form = EventForm(request.POST or None)
	if form.is_valid():
		event = form.save(commit=False)
		event.creator = request.user
		guessed_date = None

		for word in event.description.split():
			try:
				guessed_date = parse(word)
				break
			except ValueError:
				continue
		event.start_date = guessed_date
		event.save()
		messages.success(request, "Your event was posted")
		if 'next' in request.POST:
			next = request.POST['next']
		else:
			next = reverse('ev_tonight')
		return HttpResponseRedirect(next)
	return render_to_response(
		'events/create.html',
		{'form':form},
		context_instance = RequestContext(request)
	)

def test_only_title_and_state_required():
    form_data = {
        'title': 'wtf',
        'status': 'i',
        'organizer': user,
    }
    form = EventForm(data=form_data)

    assert form.is_valid(), form.errors

def test_ready_must_have_date():
    form_data = {
        'title': 'wtf',
        'status': 'r',
    }
    form = EventForm(data=form_data)

    assert not form.is_valid(), form.errors
    assert 'Un événement prêt doit avoir une date de début' in form.errors['__all__']

def add(request):
    if request.method == 'POST':
        form = EventForm(request.POST)
        if form.is_valid():
            event = form.save()
            return HttpResponseRedirect(reverse('event-edit', args=[event.id])+'?after_add=1')
    else:
        form = EventForm()

    return render_to_response('event_add.html', locals())

def test_stop_must_be_after_start():
    form_data = {
        'title': 'wtf',
        'status': 'i',
        'start': datetime(2100, 1, 1),
        'stop': datetime(2000, 1, 1)
    }
    form = EventForm(data=form_data)

    assert not form.is_valid()
    assert 'La date de fin ne peut être avant la date de début' in form.errors['__all__']

def create_event(request):
    """
        Creates an event.
    """
    form = EventForm()
    if request.method == "POST":
        form = EventForm(request.POST,request.FILES)
        if form.is_valid():
            event = form.save()
            return HttpResponseRedirect(reverse("event",args=(event.pk,)))
    return render_to_response("events/event_form.html",{"form":form},context_instance=RequestContext(request))

def new_event(request):
    if request.method == 'POST':
        form = EventForm(request.POST)
        if form.is_valid():
            event = form.save(commit=False)
            event.user = request.user
            event.save()
            return HttpResponseRedirect('/events')
    else:
        event = Event()
        form = EventForm(instance=event)
    return render_to_response('events/new_event.html', {'form': form}, context_instance=RequestContext(request))

def edit_event(request, id):
    if request.method == 'POST':
        event = get_object_or_404(Event, id=id)
        form = EventForm(request.POST, instance=event)
        if form.is_valid():
            form.save(commit=False)
            event.save()
            return HttpResponseRedirect(event.get_absolute_url())
    else:
        event = get_object_or_404(Event, id=id)
        form = EventForm(instance=event)
    return render_to_response('events/new_event.html', {'form': form, 'object': event}, context_instance=RequestContext(request))

def test_no_stop_but_start():
    form_data = {
        'title': 'wtf',
        'status': 'i',
        'start': datetime(2000, 1, 1),
        'organizer': user,
    }
    form = EventForm(data=form_data)

    assert form.is_valid(), form.errors
    assert form.cleaned_data['start'] == form.cleaned_data['stop']
    assert form.cleaned_data['start'].year == 2000

def event_create(request):
    if request.method == 'POST':
        eventform = EventForm(request.POST)
        if eventform.is_valid():
            eventform.save()
    else:
        eventform = EventForm()

    print eventform
    return render_to_response('events/event-create.html',
                              {'eventform': eventform},
                              context_instance=RequestContext(request)
                             )

def list_all_events_view(request):
    ''' A list view of all events.  Part of archives. '''
    page_name = "Archives - All Events"
    profile = UserProfile.objects.get(user=request.user)

    event_form = EventForm(
        request.POST if "post_event" in request.POST else None,
        profile=profile,
        )

    if event_form.is_valid():
        event_form.save()
        return HttpResponseRedirect(reverse('events:all'))

    # a pseudo-dictionary, actually a list with items of form (event, ongoing,
    # rsvpd, rsvp_form, already_past), where ongoing is a boolean of whether the
    # event is currently ongoing, rsvpd is a boolean of whether the user has
    # rsvp'd to the event
    events_dict = list()
    for event in Event.objects.all():
        rsvp_form = None
        if event.end_time > now():
            rsvp_form = RsvpForm(
                request.POST if "rsvp-{0}".format(event.pk) in request.POST else None,
                instance=event,
                profile=profile,
                )
            if rsvp_form.is_valid():
                rsvpd = rsvp_form.save()
                if rsvpd:
                    message = MESSAGES['RSVP_ADD'].format(event=event.title)
                else:
                    message = MESSAGES['RSVP_REMOVE'].format(event=event.title)
                messages.add_message(request, messages.SUCCESS, message)
                return HttpResponseRedirect(reverse('events:all'))

        ongoing = event.start_time <= now() and event.end_time >= now()
        rsvpd = profile in event.rsvps.all()
        events_dict.append(
            (event, ongoing, rsvpd, rsvp_form)
            )

    if request.method == "POST":
        messages.add_message(request, messages.ERROR, MESSAGES["EVENT_ERROR"])

    return render_to_response('list_events.html', {
        'page_name': page_name,
        'events_dict': events_dict,
        'now': now(),
        'event_form': event_form,
        }, context_instance=RequestContext(request))