def test_bogus_longitude(self): data = { "name": "My bar", "website": "https://www.example.com", "instagram_handle": "example", "time_zone": "America/New_York", "tap_list_provider": "untappd", "slug": "my-bar", "latitude": 34.8, "longitude": 180.00001, } serializer = VenueSerializer(data=data) self.assertFalse(serializer.is_valid(raise_exception=False))
def test_bogus_longitude(self): data = { 'name': 'My bar', 'website': 'https://www.example.com', 'instagram_handle': 'example', 'time_zone': 'America/New_York', 'tap_list_provider': 'untappd', 'slug': 'my-bar', 'latitude': 34.8, 'longitude': 180.00001, } serializer = VenueSerializer(data=data) self.assertFalse(serializer.is_valid(raise_exception=False))
def placesavailable(self, request, pk): """Get all the venues at which the given beer is on tap""" queryset = Venue.objects.filter(taps__beer__id=pk).distinct().order_by( 'name', ) # let the user use all the venue filters just for kicks queryset = VenueFilterSet(request.query_params, queryset=queryset).qs page = self.paginate_queryset(queryset) if page is not None: serializer = VenueSerializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = VenueSerializer(queryset, many=True) return Response(serializer.data)
class EventSerializer(serializers.ModelSerializer): venue = VenueSerializer(read_only=True) venue_id = serializers.PrimaryKeyRelatedField( write_only=True, required=True, allow_null=False, queryset=Venue.objects.all(), ) def validate(self, data): try: start = data['startDate'] end = data['endDate'] except KeyError: # must be in a patch; don't care pass else: if start >= end: raise serializers.ValidationError({ 'startDate': [ 'This must be before endDate', ], 'endDate': [ 'This must be after startDate', ] }) try: data['venue'] = data.pop('venue_id') except KeyError: # must be in a patch; don't care pass return data class Meta: model = models.Event fields = '__all__'
def post(self, request, format=None): user = request.user cohort = request.user.cohort_set.all().first() lat = self.request.data.get('lat', None) lng = self.request.data.get('lng', None) if lat and lng: geo_lookup_results = geo_search(lat, lng) if geo_lookup_results: print geo_lookup_results venue, created = Venue.objects.get_or_create( foursquare_id = geo_lookup_results['foursquare_id'] ) venue.name = geo_lookup_results['name'] venue.category = geo_lookup_results['category'] venue.lat = geo_lookup_results['lat'] venue.lng = geo_lookup_results['lng'] venue.save() venue_serializer = VenueSerializer(venue) return Response(venue_serializer.data, status=status.HTTP_200_OK) else: # no valid venue found return Response(status=status.HTTP_404_NOT_FOUND) else: # we need lat/lng return Response(status=status.HTTP_400_BAD_REQUEST)
def test_create(self): data = { 'name': 'My bar', 'website': 'https://www.example.com', 'instagram_handle': 'example', 'time_zone': 'America/New_York', } serializer = VenueSerializer(data=data) serializer.is_valid(raise_exception=True) instance = serializer.save() self.assertIsInstance(instance, Venue) for field, value in data.items(): with self.subTest(field=field): if field != 'time_zone': self.assertEqual(getattr(instance, field), value) else: self.assertEqual(instance.time_zone.zone, value)
def test_create(self): data = { "name": "My bar", "website": "https://www.example.com", "instagram_handle": "example", "time_zone": "America/New_York", "slug": "my-bar", } serializer = VenueSerializer(data=data) serializer.is_valid(raise_exception=True) instance = serializer.save() self.assertIsInstance(instance, Venue) for field, value in data.items(): with self.subTest(field=field): if field != "time_zone": self.assertEqual(getattr(instance, field), value) else: self.assertEqual(instance.time_zone.zone, value)
def get_venues(self, obj): from venues.serializers import VenueSerializer taps = list(obj.taps.all()) if not taps: return [] venues = {i.venue for i in taps} return VenueSerializer( instance=list(sorted(venues, key=lambda v: v.name)), many=True, ).data
def venue_nearby(request, lat, lon): venues = Venue.objects.all() venues = [ v for v in venues if haversine(float(lon), float(lat), float(v.longitude), float(v.latitude)) < 0.5 ] serializer = VenueSerializer(venues, many=True) response = JSONResponse(serializer.data) return response
def get_context_data(self, **kwargs): venues = [] for venue in self.tournament.relevant_venues.select_related('checkin_identifier').prefetch_related('venuecategory_set').all(): item = VenueSerializer(venue).data item['locked'] = False try: item['identifier'] = [venue.checkin_identifier.barcode] except ObjectDoesNotExist: item['identifier'] = [None] venues.append(item) kwargs["venues"] = json.dumps(venues) kwargs["team_codes"] = json.dumps(False) return super().get_context_data(**kwargs)
def category_venues(request, pk): """ Retrieve venues catering to requested category. """ try: print('finding ' + pk) category = Category.objects.get(pk=pk) except Category.DoesNotExist: return HttpResponse(status=404) venues = Venue.objects.filter(categories__pk=pk) if request.method == 'GET': serializer = VenueSerializer(venues, many=True) return JSONResponse(serializer.data) return JSONResponse(status=403)
def test_display_tap_list_provider(self): data = { 'name': 'My bar', 'website': 'https://www.example.com', 'instagram_handle': 'example', 'time_zone': 'America/New_York', 'tap_list_provider': 'untappd', } serializer = VenueSerializer(data=data) serializer.is_valid(raise_exception=True) instance = serializer.save() self.assertIsInstance(instance, Venue) serializer = VenueSerializer(instance=instance) self.assertEqual( serializer.data['tap_list_provider_display'], 'Untappd', )
def test_display_tap_list_provider(self): data = { "name": "My bar", "website": "https://www.example.com", "instagram_handle": "example", "time_zone": "America/New_York", "tap_list_provider": "untappd", "slug": "my-bar", } serializer = VenueSerializer(data=data) serializer.is_valid(raise_exception=True) instance = serializer.save() self.assertIsInstance(instance, Venue) serializer = VenueSerializer(instance=instance) self.assertEqual( serializer.data["tap_list_provider_display"], "Untappd", )
def construct_info(self, venue, source, source_p, target, target_p): if hasattr(source, 'name'): source_n = source.name elif use_team_code_names(self.tournament, False): source_n = source.code_name else: source_n = source.short_name return { 'venue': VenueSerializer(venue).data if venue else '', 'authorInstitution': source.institution.code if source.institution else _("Unaffiliated"), 'author': source_n, 'authorPosition': source_p, 'target': target.name, 'targetPosition': target_p, }
class TapSerializer(serializers.ModelSerializer): venue_id = serializers.PrimaryKeyRelatedField( write_only=True, allow_null=False, required=True, queryset=Venue.objects.all(), ) estimated_percent_remaining = serializers.FloatField( min_value=0, max_value=100, allow_null=True, required=False, ) venue = VenueSerializer(read_only=True) time_added = serializers.DateTimeField(read_only=True) time_updated = serializers.DateTimeField(read_only=True) def update(self, instance, validated_data): instance.time_updated = timezone.now() return super().update(instance, validated_data) def validate(self, data): try: data['venue'] = data.pop('venue_id') except KeyError: pass return data class Meta: fields = '__all__' model = models.Tap validators = [ UniqueTogetherValidator( queryset=models.Tap.objects.all(), fields=('tap_number', 'venue_id'), ), ]
def test_display(self): instance = Event.objects.create( title='test', venue=self.venue, start_time=UTC.localize(datetime.datetime(2018, 11, 20, 12)), end_time=UTC.localize(datetime.datetime(2018, 11, 20, 16)), ) serializer = EventSerializer(instance=instance) for field, value in serializer.data.items(): if field == 'venue': self.assertEqual( value, VenueSerializer(self.venue).data, field, ) elif field.endswith('_time'): self.assertEqual( value, DateTimeField().to_representation(getattr(instance, field), ), field, ) else: self.assertEqual(value, getattr(instance, field), field)
class EventSerializer(serializers.ModelSerializer): venue = VenueSerializer(read_only=True) venue_id = serializers.PrimaryKeyRelatedField( write_only=True, required=True, allow_null=False, queryset=Venue.objects.all(), ) def validate(self, data): try: start = data["start_time"] end = data["end_time"] except KeyError: # must be in a patch; don't care pass else: if start >= end: raise serializers.ValidationError({ "start_time": [ "This must be before end_time", ], "end_time": [ "This must be after start_time", ], }) try: data["venue"] = data.pop("venue_id") except KeyError: # must be in a patch; don't care pass return data class Meta: model = models.Event fields = "__all__"