def test_create_event(self): event_obj = EventSerializer(EventFactory.build()).data res = self.client.post(reverse('event-list'), data=event_obj) self.assertEqual(res.status_code, status.HTTP_201_CREATED) created_event = EventSerializer( Event.objects.get(id=res.data['id'])).data self.assertEqual(res.data, created_event)
def post(self, request): serializer = EventSerializer(data=request.data) if serializer.is_valid(raise_exception=True): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, categoryID): # categoryID = self.kwargs['categoryID'] if categoryID: category = categoryID[:4] print(category) # Tech Events handler if category == "tech": key = categoryID[4:] if key in ListOfTechnicalCategories.keys(): events = event.objects.filter( eventType__contains=ListOfTechnicalCategories[key]) serializer = EventSerializer(events, many=True) return Response({ "events": serializer.data, }) # Cultural Events handler elif category == "cult": key = categoryID[4:] if key in ListOfCulturalCategories.keys(): events = event.objects.filter( eventType__contains=ListOfCulturalCategories[key]) serializer = EventSerializer(events, many=True) return Response({ "events": serializer.data, }) elif category == "work": pass return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): serializer = EventSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_valid(self): serializer = EventSerializer(self.event) content = JSONRenderer().render(serializer.data) stream = BytesIO(content) data = JSONParser().parse(stream) serializer = EventSerializer(data=data) self.assertEqual(serializer.is_valid(), True)
def post(self, request): payload = request.data serializer = EventSerializer(data=payload) if serializer.is_valid(): serializer.save() return Response(data=serializer.data, status=201) else: return Response(data={"message":"Invalid"}, status=400)
def process_event(self, event): parsed_event = self.create_event(event) event_serializer = EventSerializer(data=parsed_event) if event_serializer.is_valid(): new_event, created = Event.objects.update_or_create( id=parsed_event['id'], defaults=parsed_event) else: print(event_serializer.errors) print("Event was invalid: " + str(parsed_event))
def test_invalid_time(self): data = { 'title': 'beer and kittens', 'end_time': '2018-10-15T11:12:34Z', 'start_time': '2018-10-16T00:00:00Z', 'description': 'No', 'venue_id': self.venue.id, } serializer = EventSerializer(data=data) self.assertFalse(serializer.is_valid())
def test_invalid_time(self): data = { "title": "beer and kittens", "end_time": "2018-10-15T11:12:34Z", "start_time": "2018-10-16T00:00:00Z", "description": "No", "venue_id": self.venue.id, } serializer = EventSerializer(data=data) self.assertFalse(serializer.is_valid())
def createEvent(self, eventType, dataTime): eventData = { 'userId': self.request.user.pk, 'eventType': eventType, 'dataTime': dataTime, 'desc': "Created from DatapointUploadCsv", } print("eventData=", eventData) serializer = EventSerializer(data=eventData) if serializer.is_valid(): serializer.save()
def parse(self, response): for event in response.css(".seite-c-single"): title = event.css(".article-title::text").extract_first() category = event.css(".article-category::text").extract_first() desc = event.css(".article-text::text").extract_first() href = self.BASE_URL + event.css(".seite-c-single ::attr(href)").extract_first() try: start = [x.strip() for x in event.css(".date-display-start ::attr(content)").extract_first().split('T')][0] start = datetime.datetime.strptime(start, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f') end = [x.strip() for x in event.css(".date-display-end ::attr(content)").extract_first().split('T')][0] end = datetime.datetime.strptime(end, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f')#2018-10-21 12:04:26.255181 2018-12-02 12:12:1543708800.000000 except: start = [x.strip() for x in event.css(".date-display-single ::attr(content)").extract_first().split('T')][0] start = datetime.datetime.strptime(start, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f') end = start event_object = Event(title=title, start_date=start, end_date=end,category=category, link=href,description=desc, web_source="Co-Berlin") serializer = EventSerializer(event_object) content = JSONRenderer().render(serializer.data) stream = io.BytesIO(content) data = JSONParser().parse(stream) serializer = EventSerializer(data=data) #print(serializer) #print(serializer.is_valid()) serializer.is_valid() try: serializer.save() except IntegrityError as e: logger.error(e.__str__())
def put(self, request, event_id): try: saved_event = Event.objects.get(pk=event_id) serializer = EventSerializer(instance=saved_event, data=request.data) if serializer.is_valid(raise_exception=True): serializer.save() notify_on_changes(saved_event) return Response(serializer.data, status=status.HTTP_202_ACCEPTED) else: return Response(status=status.HTTP_400_BAD_REQUEST) except Event.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request): data = request.data if ("poster" in data): image = data["poster"] name = data["name"] if (';base64,' in image): format, imgstr = image.split(';base64,') ext = format.split('/')[-1] dataImage = ContentFile(base64.b64decode(image), name=name + str(datetime.datetime.now()) + ".jpeg") data["poster"] = dataImage event = Event.objects.get(id=data["id"]) event.name = data["name"] if ("poster" in data): event.poster = data["poster"] event.Description = data["Description"] event.venue = data["venue"] event.timeDate = data["timeDate"] event.club = Club.objects.get(id=int(data["club"]["id"])) event.save() data = EventSerializer(event).data return Response(data, status=HTTP_201_CREATED)
def get(self, request, format=None): events = event.objects.all() serializer = EventSerializer(events, many=True) return Response({ "data": serializer.data, })
def retrieve(self, request, pk=None): try: event = Event.objects.get(pk=pk, baby__parent__user__pk=request.user.id) serializer_context = {'request': Request(request._request)} return Response(EventSerializer(event, context=serializer_context).data) except (Exception) as e: return Response("invalid_event_id", 404)
def test_delete_event_unauthorized(self): owner = AccountFactory.create() test_event = EventSerializer(EventFactory.create(organizer=owner)).data res = self.client.delete( reverse('event-detail', kwargs={'pk': test_event['id']})) self.assertEqual(res.status_code, status.HTTP_403_FORBIDDEN) self.assertTrue(Event.objects.filter(id=test_event['id']).exists())
class PaymentSerializer(serializers.ModelSerializer): event_id = serializers.IntegerField(source='event.id') event = EventSerializer() class Meta: model = Payments fields = ('timestamp', 'price', 'event_id', 'event')
class TicketReservationRetrieveSerializer(serializers.ModelSerializer): event = EventSerializer() status = serializers.CharField(source='get_status_display') class Meta: model = TicketReservation fields = ['id', 'event', 'ticket_type', 'status', 'reserved_time', 'last_modified']
def get_events(self, obj): """Gets filtred events.""" from events.serializers import EventSerializer return EventSerializer(get_fresh_prioritized_events( obj.events, self.context['request'], delta=365), many=True, read_only=True).data
def event_request(request, fromdate, todate, mLongitude, mLatitude, mDistance, mNE=100, mId=0): """ Eventrequest gives back event information in function of date and distance, optional arguments are Number of Events (default = 100) and starting ID (default = 0) """ if 'HTTP_TOKEN' not in request.META: return Response(status=status.HTTP_403_FORBIDDEN) token = request.META['HTTP_TOKEN'] if validate_user(token) is False: return Response(status=status.HTTP_403_FORBIDDEN) tdate = datetime.datetime.fromtimestamp(float(todate)) idate = datetime.datetime.fromtimestamp(float(fromdate)) maxlongitude= float(mLongitude) + float(mDistance) minlongitude= float(mLongitude) - float(mDistance) maxlatitude = float(mLatitude) + float(mDistance) minlatitude = float(mLatitude) - float(mDistance) try: event = Event.objects.filter(date__range=[idate, tdate]).filter(longitude__range= (minlongitude,maxlongitude)).filter(latitude__range= (minlatitude,maxlatitude)).filter(id__gt= mId) except Event.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) #event = Event.objects.all() if request.method == 'GET': serializer = EventSerializer(event[:mNE], many=True) return Response(serializer.data)
class ManagerProfileSerializer(serializers.ModelSerializer): manager = ManagerSerializer() events = EventSerializer(many=True, read_only=True) class Meta: model = ManagerProfile fields = '__all__'
def get_events(self, obj, status): """Returns serialized events for given status.""" from events.serializers import EventSerializer request = self.context['request'] return EventSerializer(get_fresh_prioritized_events( obj.followed_events.filter(ues__status=status), request, delta=60), many=True).data
def retrieveEventsbyBaby(self, request, pk=None): events = Event.objects.filter(baby__pk=pk) if request.user.has_perm('parents.see_baby', Baby.objects.get(pk=pk)): serializer_context = {'request': Request(request._request)} return Response(EventSerializer(events, many=True,context=serializer_context).data) else: return Response("You do not have permission to perform this action.", 404)
def test_delete_event(self): test_event = EventSerializer( EventFactory.create(organizer=self.account)).data res = self.client.delete( reverse('event-detail', kwargs={'pk': test_event['id']})) self.assertEqual(res.status_code, status.HTTP_204_NO_CONTENT) self.assertFalse(Event.objects.filter(id=test_event['id']).exists())
def search(request): """EXPENSIVE: Search with query param `query` throughout the database.""" MIN_LENGTH = 3 req_query = request.GET.get("query") if not req_query or len(req_query) < MIN_LENGTH: return Response({"message": "No query or too short!"}, status=400) # Search bodies by name and description bodies = query_search(request, MIN_LENGTH, Body.objects, ['name', 'description']) # Search events by name and description events = get_prioritized( query_search(request, MIN_LENGTH, Event.objects, ['name', 'description'])[:20], request) # Search users by only name: don't add anything else here users = query_search(request, MIN_LENGTH, UserProfile.objects, ['name', 'ldap_id', 'roll_no'])[:20] return Response({ "bodies": BodySerializerMin(bodies, many=True).data, "events": EventSerializer(events, many=True).data, "users": UserProfileSerializer(users, many=True).data })
def events(self, request, pk=None): baby = self.get_object() response = [] for event in Event.objects.filter(baby=baby): response.append(EventSerializer(event).data) return Response(response)
def get(self, request, pk): try: event = Event.objects.get(id=pk) except Event.DoesNotExist: return Response(data={"message": "Not found"}, status=404) serializer = EventSerializer(instance=event) return Response(data=serializer.data)
def test_leave_event(self): event = EventSerializer( EventFactory.create(attendees=[self.account])).data self.assertEqual(Event.objects.count(), 1) url = self.get_collection_url(event['id']) res = self.client.delete(url) self.assertEqual(res.status_code, 200) self.assertEqual(res.json(), 'guest dropped')
def set(self, request, pk=None): queryset = Event.objects.all() event = get_object_or_404(queryset, pk=pk) new_z = request.POST.get('z', None) if new_z is not None: event.z = Decimal(new_z) event.save() return Response(EventSerializer(event).data)
def test_guest_list(self): accounts = AccountFactory.create_batch(5) guest_list = list( map(lambda acc: AccountSerializer(acc).data, accounts)) event = EventSerializer(EventFactory.create(attendees=accounts)).data url = self.get_collection_url(event['id']) res = self.client.get(url) self.assertEqual(res.json()['results'], guest_list)
def put(self, request, event_id): # update an event serializer = EventSerializer(data=request.DATA) if not serializer.is_valid(): return Response(serializer.errors, \ status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data event = Event(id = event_id, owner = request.user, description = data['description'], date = data['date'], location = data['location'], tags = data['tags'], title = data['title'], link = data['link'], ) event.save() return Response(request.DATA, status = status.HTTP_200_OK)
def post(self, request): # Adding a new events serializer = EventSerializer(data=request.DATA) if not serializer.is_valid(): return Response(serializer.errors, \ status = status.HTTP_400_BAD_REQUEST) else: data = serializer.data owner = request.user event = Event(owner = owner, description = data['description'], date = data['date'], location = data['location'], tags = data['tags'], title = data['title'], link = data['link'], ) event.save() request.DATA['id'] = event.pk return Response(request.DATA, status = status.HTTP_201_CREATED)
def perform_create(self, serializer: EventSerializer): serializer.save(user=self.request.user) return super(EventViewSet, self).perform_create(serializer)