def put(self, request, pk):
"""
:param pk: the primary key of note
:param request: request for data
:return: returns the response
"""
try:
note_obj = Notes.objects.get(pk=pk)
if note_obj:
note_ser = NoteSerializers(data=request.data)
if note_ser.is_valid(raise_exception=True):
print('valid')
note = note_ser.update(instance=note_obj,
validated_data=request.data)
print("-----------", note)
if note:
return Response(note_ser.data, status=200)
else:
return Response(note_ser.errors, status=400)
else:
logger.warning("no such note present in db")
raise ValueError
except Exception as e:
return Response({"message": str(e)}, status=404)
except ValueError as e:
return Response({"message": "lklkdflkdsf"}, status=404)
def search(request):
"""
:param request: for the keyword to search
:return: the json data response
"""
try:
searchquery = request.GET.get('query')
if searchquery:
posts = NotesDocument.search().query(
Q("match", title=searchquery) | Q("match", text=searchquery))
jsondata = []
data = {'data': posts}
ids = []
for i in data['data']:
data1 = {'title': i.title, 'text': i.text, 'id': i.id}
ids.append(data1['id'])
jsondata.append(data1)
print(jsondata)
note = Notes.objects.filter(id__in=ids)
noteser = NoteSerializers(note, many=True)
return Response(noteser.data, status=200)
else:
logger.warning("no such note present in db")
raise ValueError
except ValueError:
return Response({'error': 'something went wrong!'})
def get(self, request, *args, **kwargs):
"""
:param request: request for data
:return: returns the response
"""
try:
userdata = Util.Getuser()
uid = userdata['id']
noted = Notes.objects.filter(
user=uid, is_Trash=False,
is_archive=False).order_by('-created_at')
if noted:
print("in header", request.META['HTTP_AUTHORIZATION'])
notedata = NoteSerializers(noted, many=True)
obj = pickle.dumps(notedata.data)
redisCache.set('note', obj)
logger.info('All your Notes')
return Response(notedata.data, status=200)
else:
logger.warning("note is not present")
raise ValueError
except ValueError:
return Response({'error': 'no such notes'}, status=404)
def post(self, request, *args, **kwargs):
"""
:param request: request for data
:return: returns the response
"""
response = {
'success': False,
'message': 'something went wrong ',
'data': []
}
labels = request.data.pop('label')
collaborator = request.data.pop('collaborator')
serialize = NoteSerializers(data=request.data)
print(serialize)
try:
print(serialize.is_valid())
if serialize.is_valid():
obj = serialize.save()
for i in labels:
lobj = Label.objects.get(id=i)
obj.label.add(lobj)
obj.save()
for i in collaborator:
user = User.objects.get(id=i)
obj.collaborator.add(user)
obj.save()
logger.info("Note created")
response = get_custom_response(
success=True,
message='Note successfully created',
data=serialize.data,
status=201)
else:
response = get_custom_response(message=serialize.errors)
logger.warning("not a valid info")
raise ValueError
except ValueError:
response = get_custom_response(message="value Error")
return response
def get(self, request, pk):
"""
:param pk: the primary key of note
:param request: request for data
:return: returns the response
"""
try:
noted = Notes.objects.get(pk=pk)
if noted:
notedata = NoteSerializers(noted)
return Response(notedata.data, status=200)
else:
logger.warning("no such note present in db")
raise ValueError
except ValueError:
return Response({'error': 'no such notes'}, status=404)
def get(self, request, *args, **kwargs):
"""
:param request: request for data
:return: returns the response
"""
try:
userdata = Util.Getuser()
uid = userdata['id']
note_archive = Notes.objects.filter(user=uid, is_archive=True)
note = NoteSerializers(note_archive, many=True)
if note:
return Response(note.data, status=200)
else:
logger.warning("no such note present in db")
raise ValueError
except ValueError:
return Response({'message': 'no archives found'}, status=400)
def get(self, pk):
"""
:param pk: users id
:return: the response of collaborator added successfully
"""
try:
notes = Notes.objects.get(pk=pk)
if notes:
collaboratedNotes = notes.collaborator.all()
collabCount = notes.collaborator.count()
noteSer = NoteSerializers(collaboratedNotes, many=True)
return Response({
'data': noteSer,
'count': collabCount
},
status=200)
else:
raise ValueError
except ValueError:
return Response({'error': 'no such notes'}, status=404)
def get(self, request, *args, **kwargs):
"""
:param request: request for data
:return: returns the response
"""
try:
userdata = Util.Getuser()
uid = userdata['id']
reminder = Notes.objects.filter(user=uid, reminder__isnull=False)
notes = NoteSerializers(reminder, many=True)
print(datetime.date)
# reminder = datetime.datetime.now() - datetime.timedelta(days=90)
if notes:
return Response(notes.data, status=200)
else:
logger.warning("no such note present in db")
raise ValueError
except ValueError:
return Response({'message': 'reminder not set'}, status=400)
def labelNote(request, labelname, *args, **kwargs):
"""
:param request: request for data
:param labelname: label name passed as params
:param args: arguements
:param kwargs: keyword arguements
:return: note with label
"""
try:
userdata = Util.Getuser()
uid = userdata['id']
labels = Label.objects.get(user=uid, name=labelname)
print("labeldata******", labels)
if labels:
notedata = labels.notes_set.all()
print("--------", notedata)
noteser = NoteSerializers(notedata, many=True)
return Response({'data': noteser.data}, status=200)
else:
raise ValueError
except ValueError:
return Response({'error': 'no such label'}, status=404)