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(), })
def cleanup_places(request): if not request.user.is_staff: return HttpResponseForbidden() done = [] if request.POST: for key in request.POST.keys(): if key.endswith('lat'): lat = float(request.POST[key]) lon = float(request.POST[key.replace('lat', 'lon')]) pk = key.split('_')[1] place = Place.objects.get(pk = pk) place.latitude = lat place.longitude = lon place.save() PlaceNeedsCleanup.objects.filter(place = place).delete() done.append(place) places = PlaceNeedsCleanup.objects.select_related( 'place' ) reverse = ('reverse' in request.REQUEST) if reverse: places = places.order_by('-pk') else: places = places.order_by('pk') return render(request, 'cleanup/places.html', { 'places': [p.place for p in places[:10]], 'done': done, 'reverse': reverse, 'total_places': PlaceNeedsCleanup.objects.count(), })
def moderate(request): if not request.user.is_staff: return HttpResponseForbidden() if request.method == 'POST': for k in request.POST.keys(): if k[:6]=='photo-': v = request.POST[k] if v=='0': continue ppk = int(k[6:]) photo = Photo.objects.get(pk=ppk) photo.moderated_by = request.user photo.moderated_at = datetime.datetime.now() if v=='2': photo.is_visible = True photo.save() return HttpResponseRedirect(reverse('moderate-photos')) else: photos = Photo.objects.filter( is_visible=False).filter(moderated_by=None ) return render(request, 'photos/moderate.html', { 'photos': photos[:10], 'total': photos.count() })
def login(request, template_name='registration/login.html', 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, '') suppress_register = request.REQUEST.get('suppress-register', 'false') if not redirect_to: suppress_register = 'true' if request.method == "POST": form = OurAuthenticationForm(data=request.POST) if form.is_valid(): from django.contrib.auth import login login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL return Redirect(redirect_to) else: form = OurAuthenticationForm(request) request.session.set_test_cookie() return render(request, template_name, { 'form': form, redirect_field_name: redirect_to, 'suppress_register': suppress_register, })
def bestpic(request): if request.user.is_anonymous(): species = utils.random_species_with_multiple_photos() else: species = utils.random_species_with_multiple_photos(request.user) photo1, photo2 = utils.random_photos_for_species(species) # We use a token to ensure any given form we serve up can only be # submitted once. Used tokens are stored in Redis for 6 minutes. Forms # are time-stamped, and a submission from a form older than five minutes # (or one with a token within the 6 minute cache) will silently be # discarded. token = utils.generate_token() context = { 'species': species, 'photo1': photo1, 'photo2': photo2, 'options': signed.dumps({ 'species': species.pk, 'contestants': [photo1.pk, photo2.pk], 'token': token, 'time': int(time.time()), }), 'request_path': request.path, } if request.method == 'POST': context.update(process_submission(request)) return render(request, 'bestpic/index.html', context)
def autocomplete_species(request, place_id): place = get_object_or_404(Place, pk = place_id) q = request.GET.get('q', '') results = list(search_species(q, 30)) # We're going to build three groups - species that have been sighted at # this place, species that have been sighted somewhere else, and species # that have not been sighted at all. seen_here_group = [] seen_elsewhere_group = [] not_seen_group = [] for result in results: # If it's in our Species database, annotate with a bunch of stuff species = None try: species = Species.objects.get(freebase_id = result['freebase_id']) except Species.DoesNotExist: pass if not species: result['select_id'] = 'x_%s' % result['search_id'] not_seen_group.append(result) continue # Matches a known species result['select_id'] = 's_%s' % species.id # Annotate with photo photos = Photo.objects.filter( sightings__species = species, is_visible = True ).distinct() result['photo'] = photos and unicode(photos[0].photo.thumbnail) or '' # Assign to a group and annotate with number of previous sightings num_sightings_here = Sighting.objects.filter( species = species, place = place ).count() if num_sightings_here: result['num_sightings'] = num_sightings_here seen_here_group.append(result) continue num_sightings = Sighting.objects.filter( species__freebase_id = result['freebase_id'] ).count() if num_sightings: result['num_sightings'] = num_sightings seen_elsewhere_group.append(result) continue # Not seen anywhere before not_seen_group.append(result) # Order each group by number of sightings, with most at the top seen_here_group.sort(key = lambda r: r['num_sightings'], reverse=True) seen_elsewhere_group.sort( key = lambda r: r['num_sightings'], reverse=True ) return render(request, 'trips/autocomplete_species.html', { 'seen_here': seen_here_group, 'seen_elsewhere': seen_elsewhere_group, 'not_seen': not_seen_group, 'q': q, })
def place_edit(request, country_code, slug): place, redirect_args = _get_place(country_code, slug) if redirect_args: return HttpResponseRedirect( reverse('place-edit', args=redirect_args) ) from django.contrib.contenttypes.models import ContentType if request.method == 'POST': uf = PlaceUberForm(place, request.POST) if uf.is_valid(): if 'suggest all' in request.POST.get('submit', '').lower(): changes, deletions = uf.modifications() crg = [None] def get_or_create_group(): # bad scoping! no binding. if crg[0] is None: crg[0] = ChangeRequestGroup.objects.create() return crg[0] if changes: for (obj, attrname), (oldval, newval) in changes.iteritems(): ChangeAttributeRequest.objects.create( group=get_or_create_group(), content_object=obj, attribute=attrname, old_value=oldval, new_value=newval, ) def create_add_request(uf, data, parent_ret): if uf.parent_uform: # 'place' Place object data[uf.relation] = uf.parent_uform.instance.id ct = ContentType.objects.get_for_model(uf.model) group = get_or_create_group() cor = CreateObjectRequest.objects.create( group=group, attributes=data, parent=parent_ret, reverse_relation=uf.relation or '', content_type=ct, ) return cor uf.mapadds(create_add_request) return HttpResponseRedirect(place.urls.changes_suggested) else: uf = PlaceUberForm(place) return render(request, 'places/place_edit.html', { 'place': place, 'form': uf, })
def species_fans(request, slug): species = get_object_or_404(Species, slug=slug) return render(request, 'animals/fans.html', { 'species': species, 'fans': User.objects.filter( favourite_species__species = species ), })
def invitation(request, code): try: invite_code = InviteCode.objects.get(code = code, claimed = False) except InviteCode.DoesNotExist: return render(request, 'invitereg/invalid_code.html') response = HttpResponseRedirect('/') response.set_cookie('invite_code', invite_code.code) return response
def key_details(request, key): api_key = get_object_or_404(ApiKey.objects.select_related('group'), key = key, user = request.user ) return render(request, 'api/key_details.html', { 'key': api_key, })
def species_spotters(request, slug): species = get_object_or_404(Species, slug=slug) spotters = User.objects.filter( created_sighting_set__species=species ).distinct() return render(request, 'animals/spotters.html', { 'species': species, 'spotters': spotters, })
def photo_fans(request, username, photo_id): photo = get_object_or_404( Photo, created_by__username=username, pk=photo_id ) return render(request, 'photos/fans.html', { 'photo': photo, 'fans': User.objects.filter( favourite_photos__photo = photo ) })
def suggestions(request, username): if username != request.user.username: return HttpResponseForbidden() return render(request, 'photos/suggestions.html', { 'suggestions': SuggestedSpecies.objects.filter( denorm_suggestion_for = request.user, status = 'new' ).select_related('photo').order_by('-suggested_at'), 'username': username, })
def groups(request): flickr_token = request.user.get_profile().flickr_token if not flickr_token: return flickr_redirect(request.path) client = Flickr(token = flickr_token) token_info = client.auth_checkToken() user_id = token_info['auth']['user']['nsid'] return render(request, 'flickr/groups.html', { 'groups': client.people_getPublicGroups(user_id = user_id), })
def sets(request): flickr_token = request.user.get_profile().flickr_token if not flickr_token: return flickr_redirect(request.path) client = Flickr(token = flickr_token) sets = client.photosets_getList()['photosets']['photoset'] return render(request, 'flickr/sets.html', { 'sets': sets, 'show_photos': len(sets) <= 30, })
def support(request, country_code, slug): place, redirect_args = _get_place(country_code, slug) if redirect_args: return HttpResponseRedirect( reverse('place-support', args=redirect_args) ) return render(request, 'places/place_support.html', { 'place': place, })