def create(self, request):
decoded_token = decode_token(request.META)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
event = Event()
data = serializer.data
data['calendar_id'] = -1
data['created'] = now()
data['updated'] = now()
data['user_id'] = decoded_token['user_id']
inserted = event.insert_event(data)
result = {}
if inserted.get('inserted', 0) == 1:
e = EventSerializer(event.get_event_with_pk(
inserted['generated_keys'][0]),
many=True)
if len(e.data) > 0:
result = e.data[0]
event.close()
return Response(result, status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def createEvent(request):
# product = Product.objects.get(id=pk)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
def create(self, request):
decoded_token = decode_token(request.META)
token = get_token(request.META)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
client = CalendarDBClient()
event_id = client.add_event(token, serializer.data)
st = SchedulingTask(task_type='schedule',
status='pending',
event_id=event_id,
start_time=None,
tentative_time=None,
initiator_id=decoded_token['user_id'],
result='needs_action')
re = st.save()[0]
re_s = EventSerializer(re.to_dict())
return Response(re_s.data, status=status.HTTP_201_CREATED)
return Response(
{
'data': serializer.errors,
'message': 'Event could not be created with the given data.'
},
status=status.HTTP_400_BAD_REQUEST)
def test_event_creation_with_invalid_tag(self):
data = self.valid_data['one_schedule_no_to_date']
tag1 = Tag.objects.create(name='test tag')
data['tags'] = [{"name": tag1.name}, {"name": "bad_tag_name"}]
serializer = EventSerializer(data=data)
self.assertFalse(serializer.is_valid())
self.assertEqual(set(serializer.errors.keys()), set(['tags']))
def put(self, request, eid, format=None):
event = self.get_objects(eid)
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)
def test_invalid_schedule(self):
self.client.force_login(self.winery_user)
data = self.invalid_data['empty_schedule']
serializer = EventSerializer(data=data)
self.assertFalse(serializer.is_valid())
response = self.client.post(reverse("event-list"),
data=data,
content_type="application/json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def put(self, request, event_id, format=None):
event = Event.objects.get(id=event_id)
event_serializer = EventSerializer(event, data=request.data)
if event_serializer.is_valid():
event_serializer.save()
return Response('')
return Response(event_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
app_key = request.data['app_key']
if not self.app_key_valid(app_key): #check validity of the application key
return Response(serializer.errors, status=status.HTTP_401_UNAUTHORIZED)
serializer = EventSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response("OK")
def fetch_events():
logger.info('Starting cron script... This may take some time...')
for location in Location.objects.all():
events = EventsFetcher.get_items(location)
for event in events:
serializer = EventSerializer(data=event)
if serializer.is_valid():
serializer.save()
else:
logger.error(serializer.errors)
logger.info('Finished cron script...')
def test_event_creation_endpoint_with_different_schedules(
self, data_key, expected_occurrences_count):
self.client.force_login(self.winery_user)
data = self.valid_data[data_key]
serializer = EventSerializer(data=data)
self.assertTrue(serializer.is_valid())
response = self.client.post(reverse("event-list"),
data=data,
content_type="application/json")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(set(response.json().keys()), set(["url"]))
db_event = Event.objects.first()
self.assertEqual(db_event.name, data["name"])
self.assertEqual(expected_occurrences_count,
len(db_event.occurrences.all()))
def test_event_creation_with_tags(self):
self.client.force_login(self.winery_user)
data = self.valid_data['one_schedule_no_to_date']
tag1 = Tag.objects.create(name='test tag')
tag2 = Tag.objects.create(name='other tag')
data['tags'] = [{"name": tag1.name}, {"name": tag2.name}]
serializer = EventSerializer(data=data)
self.assertTrue(serializer.is_valid())
response = self.client.post(reverse("event-list"),
data=data,
content_type="application/json")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(set(response.json().keys()), set(["url"]))
db_event = Event.objects.first()
self.assertEqual(db_event.name, data["name"])
tag_list = [tag.name for tag in db_event.tags.all()]
self.assertEqual(set(tag_list), set(['test tag', 'other tag']))
def create(self, request, calendar_id):
# self.kwargs['calendar_id']
decoded_token = decode_token(request.META)
calendar = Calendar()
obj = calendar.get(decoded_token['user_id'], calendar_id)
calendar.close()
if len(obj) < 1:
calendar_id = -1
# return Response({"message": "calendar_id does not exists."},
# status=status.HTTP_404_NOT_FOUND)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
event = Event()
data = serializer.data
data['calendar_id'] = calendar_id
data['created'] = now()
data['updated'] = now()
data['user_id'] = decoded_token['user_id']
inserted = event.insert_event(data)
event.close()
return Response({
"message": "Event created.",
"data": inserted
},
status=status.HTTP_201_CREATED)
print("OK")
print(serializer.errors)
return Response(serializer.errors)
def create(self, request):
serializer = EventSerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
serializer.save(employer=request.user.employer)
return Response(serializer.data, status=status.HTTP_201_CREATED)
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_event_creation_with_invalid_category(self):
data = self.valid_data['one_schedule_no_to_date']
data['categories'] = [{"name": "bad_category_name"}]
serializer = EventSerializer(data=data)
self.assertFalse(serializer.is_valid())
self.assertEqual(set(serializer.errors.keys()), set(['categories']))
