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 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 event_detail(request, pk, format=None):
"""
Retrieve, update or delete an event.
"""
"""
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)
"""
try:
event = Event.objects.get(pk=pk)
except Event.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = EventSerializer(event)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = EventSerializer(event, data= request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
if validate_delete(request, event.owner):
event.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(status=status.HTTP_403_FORBIDDEN)
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, 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 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 test_create(self):
data = {
'title': 'bike night',
'start_time': '2018-10-15T11:12:34+00:00',
'end_time': '2018-10-16T00:00:00+00:00',
'description': 'No',
'venue_id': self.venue.id,
}
serializer = EventSerializer(data=data)
serializer.is_valid(raise_exception=True)
instance = serializer.save()
self.assertIsInstance(instance, Event)
for field, value in data.items():
with self.subTest(field=field):
original = getattr(instance, field)
if isinstance(original, datetime.datetime):
original = original.isoformat()
self.assertEqual(original, value, field)
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 parse(self, response):
for type in response.css(".navi_level3_extra ::attr(class)"):
if type.extract() != "navi_level3_extra":
_class = ".col_teaser_{}"
for event in response.css(_class.format(type.extract())):
date = [
x.strip() for x in
event.css("." + type.extract() +
" ::attr(title)").extract_first().split(':')
][0]
title = [
x.strip() for x in
event.css("." + type.extract() +
" ::attr(title)").extract_first().split(':')
][1]
start = datetime.datetime.strptime(
date, '%a %d %B %Y').strftime('%Y-%m-%d')
end = datetime.datetime.strptime(
date, '%a %d %B %Y').strftime('%Y-%m-%d')
category = response.css("." + type.extract() +
"::text").extract_first()
href = self.BASE_URL + event.css(
"." + type.extract() +
" ::attr(href)").extract_first()
desc = event.css("." + type.extract() +
"_color span::text").extract()[1]
event_object = Event(title=title,
start_date=start,
end_date=end,
category=category,
link=href,
description=desc,
web_source="Berghain")
serializer = EventSerializer(event_object)
content = JSONRenderer().render(serializer.data)
stream = io.BytesIO(content)
data = JSONParser().parse(stream)
serializer = EventSerializer(data=data)
serializer.is_valid()
try:
serializer.save()
except IntegrityError as e:
logger.error(e.__str__())
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 create_event(self, request):
manager = Manager.objects.get(id = request.user.id)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
serializer.save(manager=manager)
serializer.save()
logger.info(f'Event object was created, ID:{serializer.instance.id}')
return Response(serializer.data, status=201)
logger.warning(f'Event object was not created by {manager.username}')
logger.error(f'Server error')
return Response(serializer.errors, status=500)
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 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 index(request):
if request.method == 'GET':
events = Event.objects.all()
serializer = EventSerializer(events, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = EventSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def event_list(request, format=None):
"""
List all events, or create a new event.
"""
if request.method == 'GET':
events = Event.objects.all()
serializer = EventSerializer(events, many=True)
return Response(serializer.data)
elif request.method == 'POST':
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_api_create_event(client, example_user, jwt_headers):
""" Создание нового объявления. """
data = {
'payload': {
'some': 'payload'
},
'recipients': [str(example_user.uuid)]
}
response = client.post(reverse('v2:event-list'),
data=json.dumps(data),
**jwt_headers)
assert response.status_code == status.HTTP_201_CREATED
# Используем сериализатор для проверки данных
serializer = EventSerializer(data=response.data)
assert serializer.is_valid()
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 event_list(request, format=None):
"""
List all events, or create an event.
"""
"""
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)
"""
if request.method == 'GET':
events = Event.objects.all()
serializer = EventSerializer(events, many=True)
return Response(serializer.data)
elif request.method == 'POST':
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 event_detail(request, messageId, format=None):
"""
Retrieve, update or delete a code event.
"""
try:
event = Event.objects.get(messageId=messageId)
except Event.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = EventSerializer(event)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = EventSerializer(event, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
event.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
