Python shortcuts.render函数代码示例

def submit(request):
    form_class = form_for_request(request)
    if request.method == 'POST':
        form = form_class(request.POST)
        if form.is_valid():
            feedback = form.save(commit = False)
            feedback.from_page = request.REQUEST.get('from-page', '')[:255]
            feedback.ip_address = request.META.get('REMOTE_ADDR', '')[:40]
            feedback.user_agent = request.META.get(
                'HTTP_USER_AGENT', ''
            )[:255]
            if not request.user.is_anonymous():
                feedback.user = request.user
            feedback.save()
            if request.is_ajax():
                template = 'feedback/thanks_ajax.html'
            else:
                template = 'feedback/thanks.html'
            return render(request, template)
    else:
        form = form_class()
    
    if request.is_ajax():
        template = 'feedback/submit_ajax.html'
    else:
        template = 'feedback/submit.html'
    
    return render(request, template, {
        'form': form,
        'from_page': request.REQUEST.get('from-page', ''),
    })

def add_trip_select_place(request):
    """
    If a user opts to "add a trip" without starting on a place page, we first 
    need to determine where the trip took place. We offer users a search 
    form for this. If they search and STILL can't find the place they went 
    to, we allow them to add a brand new place to our database. This place 
    will not be marked as "approved" until a member of site staff has 
    approved it. Unapproved places do not show up in browse or global search 
    and are not linked to from anywhere other than the user's own trip page.
    They DO show up in this particular search form though, but ranked lower 
    than matches that are approved.
    """
    q = request.GET.get('q', '')
    if not q:
        return render(request, 'trips/add_trip_select_place.html')
    
    # TODO: use the search engine for this
    places = Place.objects.filter(known_as__icontains = q)
    
    suggested_title = q
    if not re.search('[A-Z]', suggested_title):
        suggested_title = suggested_title.title()
    
    return render(request, 'trips/add_trip_select_place_results.html', {
        'q': q,
        'places': places,
        'form': AddPlaceForm(initial={'known_as': suggested_title}),
    })

def place_species_view(request, country, place, species):
    place, redirect_args = _get_place(country, place)
    if redirect_args:
        return HttpResponseRedirect(
            reverse('place-species-view', args=redirect_args + (species,))
        )
    
    species = get_object_or_404(Species, slug=species)
    place_species_list = PlaceSpeciesSolelyForLinking.objects.filter(
        place=place
    ).filter(species=species)
    if len(place_species_list)==0:
        # auto-create here
        place_species = PlaceSpeciesSolelyForLinking(
            place=place, species=species
        )
        place_species.save()
    else:
        place_species = place_species_list[0]

    sightings = Sighting.objects.filter(
        species=species
    ).filter(place=place)

    return render(request, 'places/place_species_view.html', {
        'place': place,
        'place_species': place_species,
        'species': species,
        'sightings': sightings,
    })

def place(request, country_code, slug):
    place, redirect_args = _get_place(country_code, slug)
    if redirect_args:
        return HttpResponseRedirect(
            reverse('place', args=redirect_args)
        )
    
    species_list = place.get_species(request.user, SPECIES_ON_PLACE_PAGE + 1)
    times_sorted = get_times_sorted(place)
    
    return render(request, 'places/place.html', {
        'place': place,
        'species_list': species_list[0:SPECIES_ON_PLACE_PAGE],
        'species_list_more': len(species_list) > SPECIES_ON_PLACE_PAGE,
        'opening_times': times_sorted,
        'rating' : Trip.get_average_rating(place),
        'been_here': Trip.objects.filter(
            place = place, created_by = request.user
        ).count(),
        'places_nearby': place.nearby.filter(
            place__is_unlisted = False
        ).select_related(
            'place', 'place__country'
        )[:3],
    })

def ajax_nearby_places(request):
    latitude = request.GET.get('latitude', None)
    longitude = request.GET.get('longitude', None)
    if latitude is None or longitude is None:
        return HttpResponse('')
    places, results_info, ignore = search_places(
        SEARCH_ALL, latlon=(latitude, longitude), details=True
    )
    places = [p for p in places if not p.is_unlisted]
    
    # Calculate distance to each place
    for place in places:
        try:
            place.distance = ([
                d for d in results_info['items'] 
                if d['id'] == 'places.Place:%s' % place.id
            ][0]['geo_distance']['latlon'] / 1609.344)
        except (KeyError, IndexError):
            pass
    
    # Filter out places more than 50 miles away
    places = [
        p for p in places if p.distance <= 50
    ]
    if not places:
        return HttpResponse('')
        
    return render(request, 'trips/ajax_nearby_places.html', {
        'places': places[:5],
    })

def add_trip_add_place(request):
    if request.method == 'POST':
        form = AddPlaceForm(request.POST)
        if form.is_valid():
            place = form.save(commit = False)
            place.known_as = place.known_as.strip()
            if not place.legal_name:
                place.legal_name = place.known_as
            place.is_confirmed = False
            # Derive an unused slug
            append = 1
            first_slug = slugify(place.known_as)
            if first_slug.startswith('unlisted'):
                first_slug = 'x' + first_slug
            slug = first_slug
            while Place.objects.filter(slug = slug).count() or \
                    PlaceRedirect.objects.filter(slug = slug).count() or \
                    slug in BANNED_PLACE_SLUGS:
                slug = '%s-%d' % (first_slug, append)
                append += 1
            place.slug = slug
            place.save()
            form.save_m2m() # for categories
            return Redirect(place.get_absolute_url() + 'add-trip/')
    else:
        form = AddPlaceForm()
    return render(request, 'trips/add_trip_add_place.html', {
        'form': form,
        'countries': Country.objects.all(),
    })

def index(request):
    context = {
        'photos': Photo.objects.filter(
            is_visible = True
        ).select_related('created_by').order_by('-created_at')[:16],
        'recent_trips': Trip.objects.select_related(
            'created_by', 'place', 'place__country'
        ).order_by('-created_at')[:10],
    }
    if not request.user.is_anonymous():
        context['is_logged_in'] = True
        context['photos_of_your_favourites'] = Photo.objects.filter(
            is_visible = True
        ).filter(
            sightings__species__favourited__user = request.user
        ).select_related('created_by').order_by('-created_at')[:16]
        context['trips_to_places_you_have_been'] = Trip.objects.filter(
            place__trip__created_by = request.user
        ).exclude(
            created_by = request.user
        ).select_related(
            'created_by', 'place', 'place__country'
        ).order_by('-created_at')[:10]
        context['favourite_species'] = request.user.\
            favourite_species.select_related('species')
    
    return render(request, 'explore/index.html', context)

def edit_trip(request, username, trip_id):
    user = get_object_or_404(User, username=username)
    trip = get_object_or_404(Trip, id=trip_id, created_by=user)
    if request.user.id != user.id:
        return HttpResponseForbidden()

    if request.method=='POST':
        form = EditTripForm(request.POST, instance=trip)
        sightings_formset = SightingFormSet(request.POST, instance=trip)
        
        if form.is_valid() and sightings_formset.is_valid():
            dates_match = False
            if trip.end == trip.start:
                dates_match = True
            trip2 = form.save(commit = False)
            if trip2.end == trip.end and dates_match:
                # Preserve matching start/end dates unless the end date has 
                # been explicitly changed (which won't happen at the moment as 
                # we don't offer it in the interface)
                trip2.end = trip.start
            trip2.save()
            sightings_formset.save()
            
            # we need to make a dictionary of all POST variables starting 'saw.' since these
            # are generated by the inline sightings-to-add-to-this-trip bit (whether in script
            # or noscript mode).
            #
            # We only bother using this (via the pick sightings for given place view) if there's
            # actual data in there (so the default blank couple of input boxes doesn't excite us).
            next_vars = {}
            add_sightings = False
            for k in request.POST.keys():
                if k.startswith('saw.'):
                    next_vars[k] = request.POST[k]
                    if next_vars[k]:
                        add_sightings = True
            if add_sightings:
                next_vars['trip'] = trip2.pk
                return Redirect(
                    reverse(
                        'place-pick_sightings_for_place',
                        args=(
                            trip2.place.country.country_code,
                            trip2.place.url_slug(),
                        )
                    ) + '?' + urllib.urlencode(
                        next_vars
                    )
                )
            else:
                return Redirect(reverse('trip-view', args=(username, trip_id,)))
    else:
        form = EditTripForm(instance=trip)
        sightings_formset = SightingFormSet(instance = trip)
    
    return render(request, 'trips/trip_edit.html', {
        'trip': trip,
        'form': form,
        'sightings_formset': sightings_formset,
    })

def edit(request, slug):
    if not request.user.is_staff:
        return HttpResponseForbidden()
    l = get_object_or_404(List, slug = slug)
    not_found = []
    if request.method == 'POST':
        freebase_ids = request.POST.getlist('freebase_id')
        for id in freebase_ids:
            id = id.replace('#', '').strip()
            if not id:
                continue
            species = None
            matches = Species.objects.filter(freebase_id = '/guid/%s' % id)
            if matches:
                species = matches[0]
            else:
                search_results = search(id)
                if search_results:
                    species = species_for_freebase_details(search_results[0])
                else:
                    not_found.append(id)
                    continue
            l.species.add(species)
    
    return render(request, 'lists/edit.html', {
        'l': l,
        'not_found': not_found,
        'range_100': range(100)
    })

def your_keys(request):
    if request.method == 'POST':
        if 'create_key' in request.POST:
            purpose = request.POST.get('purpose', '')
            group, created = ApiKeyGroup.objects.get_or_create(
                name = 'default'
            )
            key = ApiKey.create_for_user(request.user, group, purpose)
            return HttpResponseRedirect('/api/your-keys/')
        
        # Are they deleting a key?
        for k in request.POST.keys():
            if k.startswith('delete_'):
                key = k.replace('delete_', '')
                try:
                    api_key = ApiKey.objects.get(
                        key = key,
                        user = request.user
                    )
                    api_key.delete()
                except ApiKey.DoesNotExist:
                    pass
                return HttpResponseRedirect('/api/your-keys/')
    
    return render(request, 'api/your_keys.html', {
        'keys': request.user.api_keys.select_related('group').order_by(
            'created_at'
        ),
    })

def register(request, redirect_field_name=REDIRECT_FIELD_NAME):
    if request.user.is_authenticated():
        return Redirect(request.REQUEST.get(redirect_field_name, '/'))

    redirect_to = request.REQUEST.get(redirect_field_name, '')

    if request.method == 'POST':
        form = RegistrationForm(request.POST)
        if form.is_valid():
            user = form.save()
            p = user.get_profile()
            p.send_validation_email()
            if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
                redirect_to = reverse('accounts-registration-complete')
            else:
                # log them in temporarily; when they close their browser they won't be
                # able to log in again because this account hasn't passed email verification
                # yet. But allows them to get straight on with using the site.
                from django.contrib.auth import login, authenticate
                user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
                login(request, user)
            return Redirect(redirect_to)
    else:
        form = RegistrationForm()
    return render(request, 'accounts/register.html', {
        'form': form,
        'next': redirect_to,
    })

def hit_parade(request):
    species_list = FavouriteSpecies.hit_parade()
    species_list = species_list[:HIT_PARADE_LENGTH]

    sightings = Sighting.objects.all()
    obscure = {}
    for s in sightings:
        if s.species:
            obscure[s.species] = obscure.get(s.species, 0) + 1

    obscure_list = obscure.keys()
    for idx in range(len(obscure_list)-1, -1, -1):
        if obscure_list[idx] in species_list:
            del obscure_list[idx]

    for s in obscure_list:
        s.count = obscure[s]

    obscure_list.sort(key=lambda s: s.count)
    obscure_list = obscure_list[:OBSCURE_LENGTH]

    return render(request, 'favourites/hit_parade.html', {
        'species_list': species_list,
        'obscure_species': obscure_list,
    })

def upload_trip(request, username, trip_id):
    raise Http404, 'Photo upload is disabled'
    user = get_object_or_404(User, username=username)
    trip = get_object_or_404(Trip, id=trip_id, created_by=user)
    # The user should have got here via a file upload PUSH. If so, we 
    # create the photo straight away and redirect them straight to the edit
    # page.
    if request.method == 'POST':
        form = PhotoOnlyForm(request.POST, request.FILES)
        if form.is_valid():
            photo = form.save(commit = False)
            photo.trip = trip
            # Set the title to the filename, if provided
            photo.title = form.cleaned_data['photo'].name
            # If user has account 7 days or older, or is staff
            # go live straight away
            if request.user.get_profile().is_not_brand_new_account() or \
                request.user.is_staff:
                photo.is_visible = True
            photo.save()
            # Redirect them straight to the edit page for that photo
            return HttpResponseRedirect(photo.get_absolute_url() + 'edit/')

    form = PhotoOnlyForm()
    return render(request, 'photos/single_upload.html', {
        'form': form,
        'action': request.path,
        'limit': settings.FILE_UPLOAD_SIZE_LIMIT,
    })

def upload(request, place=None, redirect_to=None):
    raise Http404, 'Photo upload is disabled'
    if request.method == 'POST':
        # Process uploaded photo
        form = UploadPhotoForm(request.POST, request.FILES)
        if form.is_valid():
            obj = form.save(commit = False)
            if place:
                obj.place = place
            # If user has account 7 days or older, or is staff
            # go live straight away
            if request.user.get_profile().is_not_brand_new_account() or \
                request.user.is_staff:
                obj.is_visible = True
            obj.save()
            return HttpResponseRedirect(redirect_to or (
                reverse('accounts-profile', args=(request.user,))
            ))
    else:
        form = UploadPhotoForm()

    return render(request, 'photos/upload.html', {
        'form': form,
        'attach_to': place,
        'limit': settings.FILE_UPLOAD_SIZE_LIMIT,
    })

def moderation_queue(request):
    if not request.user.is_staff:
        return HttpResponseForbidden()

    if request.method == 'POST':
        form = ChangeRequestActionForm(request.POST)

        if form.is_valid():
            action = form.cleaned_data['action']
            changerequest = form.cleaned_data['changerequest'].get_real()

            if action in ('apply', 'force'):
                changerequest.apply(request.user)
            elif action == 'delete':
                changerequest.delete()

            return HttpResponseRedirect(reverse('admin-moderation'))

    else:
        form = ChangeRequestActionForm()

    return render(request, 'changerequests/queue.html', {
        'form': form,
        'change_request_groups':
            ChangeRequestGroup.objects.filter(
                changerequest__applied_by__isnull=True
            ).distinct(),
        'total_pending_change_requests':
            ChangeRequest.objects.filter(applied_by__isnull=True).count(),
    })