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 list(self, request):
decoded_token = decode_token(request.META)
serializer = InvitationSerializer(
Invitation.objects.filter(attendee=decoded_token['user_id']),
many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
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 list(self, request):
decoded_token = decode_token(request.META)
serializer = SchedulingTaskSerializer(SchedulingTask.objects.filter(
initiator_id=decoded_token['user_id']),
many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def has_permission(self, request, view):
if request.method in SAFE_METHODS:
return True
token = decode_token(request.META)
if token is None:
return False
return True
def destroy(self, request, pk=None):
decoded_token = decode_token(request.META)
event = Event()
deleted = event.delete_event_with_user_id(
pk, int(decoded_token['user_id']))
event.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def list(self, request):
decoded_token = decode_token(request.META)
calendar = Calendar()
serializer = CalendarSerializer(calendar.list(
decoded_token['user_id']),
many=True)
calendar.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def destroy(self, request, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
SchedulingTask.objects.filter(id=pk).delete()
return Response({"message": "Deleted."}, status=status.HTTP_200_OK)
def list(self, request, calendar_id):
decoded_token = decode_token(request.META)
event = Event()
serializer = EventSerializer(event.list_events(
decoded_token['user_id'], calendar_id),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def accept(self, request, pk=None):
decoded_token = decode_token(request.META)
q = Invitation.objects.filter(attendee=decoded_token['user_id'], pk=pk)
if q.exists():
q = q[0]
q.answered = True
q.decision = True
q.save()
return Response({"data": "Invitation accepted."},
status=status.HTTP_200_OK)
def pending(self, request):
print("ENTRA?")
decoded_token = decode_token(request.META)
serializer = InvitationSerializer(Invitation.objects.filter(
attendee=decoded_token['user_id'], answered=False),
many=True)
print("PENDING")
print(serializer)
print(serializer.data)
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
decoded_token = decode_token(request.META)
preference_manager = UserPreferencesManager()
x = preference_manager.list_or_default(decoded_token['user_id'])
# serializer = PreferenceSerializer(
# preference_manager.list_or_default(decoded_token['user_id']),
# many=True)
preference_manager.close()
return Response(x, status=status.HTTP_200_OK)
def destroy(self, request, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
preference_manager = UserPreferencesManager()
deleted = preference_manager.delete(decoded_token['user_id'], pk)
preference_manager.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def destroy(self, request, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
deleted = calendar.delete(decoded_token['user_id'], pk)
calendar.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def default(self, request):
decoded_token = decode_token(request.META)
preference_manager = UserPreferencesManager()
preference_manager.delete_all(decoded_token['user_id'])
# for elem in DEFAULT_PREFERENCES:
# data = elem
# data['user_id'] = decoded_token['user_id']
# preference_manager.insert(data)
preference_manager.close()
return Response({"data": "All the preferences has been created"},
status=status.HTTP_201_CREATED)
def free_busy(self, request, calendar_id):
decoded_token = decode_token(request.META)
from_date = request.data('from_date', now() - timedelta(days=14))
to_date = request.data('to_date', now() + timedelta(days=14))
event = Event()
serializer = EventSerializer(event.free_busy(decoded_token['user_id'],
from_date, to_date),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def retrieve(self, request, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
serializer = CalendarSerializer(calendar.get(decoded_token['user_id'],
pk),
many=True)
calendar.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def update(self, request, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
preference_manager = UserPreferencesManager()
# TODO Catch if not exists
pref_instance = preference_manager.get(decoded_token['user_id'], pk)
if len(pref_instance) == 0:
preference_manager.close()
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
else:
pref_instance = pref_instance[0]
serializer = PreferenceSerializer(instance=pref_instance,
data=request.data,
partial=True)
if serializer.is_valid():
data = serializer.data
data['user_id'] = decoded_token['user_id']
data['preference_name'] = serializer.validated_data.get(
'preference_name', data['preference_name'])
data['preference_type'] = serializer.validated_data.get(
'preference_type', data['preference_type'])
data['event_type'] = serializer.validated_data.get(
'event_type', data['event_type'])
# data['attributes'] = json.loads(serializer.validated_data.get(
# 'attributes', data['attributes']))
data['attributes'] = serializer.validated_data.get(
'attributes', data['attributes'])
updated = preference_manager.update(pk, data)
preference_manager.close()
return Response({"data": updated}, status=status.HTTP_200_OK)
preference_manager.close()
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def available(self, request, calendar_id):
decoded_token = decode_token(request.META)
from_date = request.data.get('from_date', None)
to_date = request.data.get('to_date', None)
if from_date is None or to_date is None:
return Response(
{
'message':
'Invalid information provided, please include values for from_date and to_date.'
},
status=status.HTTP_400_BAD_REQUEST)
event = Event()
result = event.available(decoded_token['user_id'], from_date, to_date)
event.close()
return Response({"available": result}, status=status.HTTP_200_OK)
def create(self, request):
decoded_token = decode_token(request.META)
serializer = CalendarSerializer(data=request.data)
if serializer.is_valid():
calendar = Calendar()
data = serializer.data
data['user_id'] = decoded_token['user_id']
inserted = calendar.insert(data)
calendar.close()
return Response({
"message": "Calendar created.",
"data": inserted
},
status=status.HTTP_201_CREATED)
return Response(
{
'data': serializer.errors,
'message': 'Calender could not be created with the given data.'
},
status=status.HTTP_400_BAD_REQUEST)
def destroy(self, request, calendar_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
obj = calendar.get(decoded_token['user_id'], calendar_id)
calendar.close()
if len(obj) < 1:
return Response({"message": "calendar_id does not exists."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
deleted = event.delete_event(calendar_id, pk)
event.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def update(self, request, calendar_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
obj = calendar.get(decoded_token['user_id'], calendar_id)
calendar.close()
if len(obj) < 1:
return Response({"message": "calendar_id does not exists."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
# TODO Revisarlo con el serializer
data = request.data
data['updated'] = now()
updated = event.update_event(calendar_id, pk, data)
event.close()
return Response({"data": updated}, status=status.HTTP_200_OK)
def create(self, request):
decoded_token = decode_token(request.META)
serializer = PreferenceSerializer(data=request.data)
print(request.data)
if serializer.is_valid():
preference_manager = UserPreferencesManager()
data = serializer.data
data['user_id'] = decoded_token['user_id']
data['attributes'] = json.loads(request.data['attributes'])
inserted = preference_manager.insert(data)
preference_manager.close()
return Response(
{
"message": "Preference created.",
"data": inserted
},
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 has_object_permission(self, request, view, obj):
# Write permissions are only allowed to the owner of the snippet.
token = decode_token(request.META)
return obj.user.email == token['email']
def has_object_permission(self, request, view, obj):
# Write permissions are only allowed to the owner of the snippet.
if request.method not in SAFE_METHODS:
token = decode_token(request.META)
return obj.email == token['email']
return True
def has_permission(self, request, view):
token = decode_token(request.META)
if token is None:
return False
return True
