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)
