def delete(self, request, label_id):
"""
:param request: client request for delete label
:param label_id: delete by label id
:return: return response
"""
try:
result = redis_db.hdel(request.user.id, label_id)
if result != 0:
get_label = Label.objects.get(id=label_id, user_id=request.user.id)
get_label.delete()
response = servicesnote.smd_response(success=True, message='label is successfully deleted',
http_status=status.HTTP_204_NO_CONTENT)
logger.info('requested label is successfully deleted' + ' for %s', request.user)
elif Label.objects.filter(user_id=request.user.id, id=label_id).exists():
get_label = Label.objects.get(id=label_id, user_id=request.user.id)
get_label.delete()
response = servicesnote.smd_response(success=True, message='label is successfully deleted',
http_status=status.HTTP_204_NO_CONTENT)
logger.info('requested label is successfully deleted' + ' for %s', request.user)
else:
logger.error('label does not exist in database' + ' for %s', request.user)
response = servicesnote.smd_response(message='Label does not exist in database',
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def get(self, request):
# pdb.set_trace()
user = request.user
try:
# pdb.set_trace()
note_data = FundooNote.objects.filter(user_id=user.id)
reminder_list = note_data.values_list('reminder', flat=True)
expire = []
pending = []
for i in range(len(reminder_list.values())):
if reminder_list.values()[i]['reminder'] is None:
continue
elif timezone.now() > reminder_list.values()[i]['reminder']:
expire.append(reminder_list.values()[i])
else:
pending.append(reminder_list.values()[i])
reminder = {
'fired': expire,
'pending': pending
}
# pdb.set_trace()
logger.info("Reminders data is loaded")
return servicesnote.smd_response(message="Reminder data is:",
data={k: {i[j]['id']: i[j]['reminder'] for j in range(len(i))}
for k, i in reminder.items()},
# data={i[0]['id']: i[0]['reminder'] for i in reminder.values()},
http_status=status.HTTP_200_OK)
except TypeError:
logger.info("no reminder set")
return servicesnote.smd_response(message="No reminder set",
http_status=status.HTTP_200_OK)
def get(self, request):
"""
:param request: user request for fetching all notes created by requested user
:return: smd response
"""
try:
user_redis_note = redis_db.hvals(str(request.user.id) + 'note')
logger.info("select user notes from redis cache" + ' for %s', request.user)
if len(user_redis_note) < 1:
servicesnote.write_through(request)
user_redis_note = redis_db.hvals(str(request.user.id) + 'note')
ans = []
user_redis_note = [ast.literal_eval(user_note.decode('utf-8')) for user_note in user_redis_note]
for p in user_redis_note:
if p['is_trashed']:
ans.append(p)
response = servicesnote.smd_response(success=True, message='following is trashed note',
data=ans,
http_status=status.HTTP_200_OK)
except (KeyError, ValueError, TypeError)as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request):
"""
:param request: request parameter use for get data of Note like note title and note content
:return: if note is not empty then render on share page
"""
try:
note_data = NoteShareSerializer(data=request.data)
if not 'title' in note_data.initial_data or not 'content' in note_data.initial_data:
logger.error("title/content field not present in Note serializer" + ' for %s', request.user)
raise KeyError('title/content field not present in Note serializer')
# print(note_data.initial_data)
if note_data.is_valid():
context = {
'title': note_data.data['title'],
'content': note_data.data['content'],
'domain': request.build_absolute_uri
}
response = servicesnote.smd_response(success=True, message='share your note successfully',
http_status=status.HTTP_201_CREATED)
# return render(request, 'Example')
else:
response = servicesnote.smd_response(message='something is wrong', http_status=
status.HTTP_400_BAD_REQUEST)
logger.error('Note share serializer not valid' + ' for %s', request.user)
except (ValueError, TypeError, KeyError) as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request):
"""
:param request: request for create label
:return: smd response
"""
try:
#todo rename data (new)
data = LabelSerializer(data=request.data)
if not 'name' in data.initial_data:
logger.error("'name' field not present in label serializer" + ' for %s', request.user)
raise KeyError("'name' field not present in label serializer")
if data.is_valid():
label_record = data.save(user_id=request.user.id)
logger.info('user created Label saved in database' + ' for %s', request.user)
redis_db.hmset(str(request.user.id) + 'label', {label_record.id: label_record.name})
logger.info("user created label saved in redis cache." + ' for %s', request.user)
response = servicesnote.smd_response(success=True, message='You are successfully saved',
http_status=status.HTTP_201_CREATED)
else:
response = servicesnote.smd_response(message='serializer not valid',
http_status=status.HTTP_400_BAD_REQUEST)
except (TypeError, KeyError, ValueError) as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def put(self, request, image_id):
"""
:param image_id:
:param request: request file details which user need to post
:return: response in smd format
"""
try:
# pdb.set_trace()
instance = UserProfile.objects.get(id=image_id)
file_serialize = UploadSerializer(instance, data=request.FILES, partial=True)
if not 'image' in file_serialize.initial_data:
logger.error('image field not present')
raise KeyError('image field not present')
if file_serialize.is_valid():
file_serialize.save()
# pdb.set_trace()
response = util.smd_response(success=True, message='You file is successfully update',
data={'image_url': file_serialize.data['image']},
http_status=status.HTTP_200_OK)
logger.info('update successfully')
else:
logger.error('Image serializer data not valid.')
response = util.smd_response(message='file not update', http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(e)
response = util.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
return response
def activate(request, token):
"""
:param request: request use for which user is requesting for activate there account
:param token: token is in jwt encoded it is in short length by using django shortUrl
:return: response of user request
"""
try:
try:
# pdb.set_trace()
token = ShortURL.objects.get(surl=token)
decoded_token = util.decode_token(token.lurl)
user = User.objects.get(username=list(decoded_token.keys())[0])
except Exception as e:
logger.error('Invalid token')
user = None
if user is not None:
if not user.is_active:
user.is_active = True
user.save()
response = util.smd_response(success=True,
message='Thank you for confirmation.',
http_status=status.HTTP_202_ACCEPTED)
logger.info('user email confirmation done')
else:
logger.error('linked already used')
response = util.smd_response(message='Link already used',
http_status=status.HTTP_208_ALREADY_REPORTED)
else:
response = util.smd_response(message='link is not correct',
http_status=status.HTTP_400_BAD_REQUEST)
except:
response = util.smd_response(message='something is wrong',
http_status=status.HTTP_404_NOT_FOUND)
return response
def get(self, request):
"""
:param request: client request for get label
:return: return required response
"""
try:
user_id = request.user.id
user_redis_labels = redis_db.hvals(user_id)
if len(user_redis_labels) < 1:
logger.info("Label are not present in redis cache" + ' for %s', request.user)
get_label = Label.objects.filter(user_id=user_id)
logger.info("get all label form database" + ' for %s', request.user)
for x in range(len(get_label)):
redis_db.hmset((str(user_id) + 'label'),
{get_label.values()[x]['id']: get_label.values()[x]['name']})
logger.info("all labels insert into redis cache" + ' for %s', request.user)
user_redis_labels = redis_db.hgetall(str(user_id) + 'label')
print(type(user_redis_labels))
response = servicesnote.smd_response(success=True, message='following is/are your labels',
data=[{label_key.decode('utf-8'): lable_value.decode('utf-8')}
for label_key, lable_value in user_redis_labels.items()],
# data=[user_redis_labels],
http_status=status.HTTP_200_OK)
logger.info("all labels of current user" + ' for %s', request.user)
except TypeError as e:
logger.info(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.info(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def get(self, request, label_id):
"""
:param label_id: get label by label_id
:param request: client request for get label
:return: return required response
"""
try:
user_id = request.user.id
if redis_db.hexists(str(user_id) + 'label', label_id) != 0:
label = redis_db.hget(str(user_id) + "label", label_id)
logger.info("label fetched from redis cache" + ' for %s', request.user)
response = servicesnote.smd_response(success=True, message='your label is',
data=[label.decode('utf-8')],
http_status=status.HTTP_200_OK)
elif Label.objects.filter(user_id=user_id, id=label_id).exists():
label = Label.objects.get(id=label_id)
redis_db.hmset(str(user_id) + 'label', {label_id: {label_id: label}})
logger.info('fetching from label database and store in redis cache' + ' for %s', request.user)
response = servicesnote.smd_response(success=True, message='your label is',
data=[str(label)],
http_status=status.HTTP_200_OK)
else:
logger.error('label not present database' + ' for %s', request.user)
response = servicesnote.smd_response(message='label does exist',
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def get(request):
"""
:return:
"""
try:
response = util.smd_response(success=True, message="You are authenticated user",
http_status=status.HTTP_200_OK)
logger.info('user entered into there profile')
except:
response = util.smd_response(message="something is wrong", http_status=status.HTTP_404_NOT_FOUND)
return response
def put(self, request, note_id):
"""
:param request: data is requested
:param note_id: note id
:return: will fetch note id from database
"""
try:
instance = FundooNote.objects.get(id=note_id)
data = request.data
request_label, request_collaborate = [], []
is_label, is_collaborate = False, False
if 'label' in request.data:
is_label = True
request_label = data['label']
data["label"] = [Label.objects.get(name=name).id for name in request_label]
if 'collaborate' in request.data:
is_collaborate = True
request_collaborate = data['collaborate']
data["collaborate"] = [User.objects.get(email=email).id for email in request_collaborate]
serializer = NotesSerializer(instance, data=data, partial=True)
if serializer.is_valid():
serializer.save()
logger.info('Update in database' + ' for %s', request.user)
redis_note = redis_db.hget(str(request.user.id) + 'note', note_id)
if is_label:
serializer.initial_data['label'] = request_label
if is_collaborate:
serializer.initial_data['collaborate'] = request_collaborate
redis_note = ast.literal_eval(redis_note.decode('utf-8'))
for key, val in serializer.initial_data.items():
redis_note[key] = val
redis_db.hmset(str(request.user.id) + 'note', {note_id: redis_note})
logger.info('Update in redis cache' + ' for %s', request.user)
response = servicesnote.smd_response(success=True, message='note updated',
http_status=status.HTTP_200_OK)
else:
logger.error("data not valid serialized" + ' for %s', request.user)
response = servicesnote.smd_response(message='note was not update',
http_status=status.HTTP_400_BAD_REQUEST)
except (ValueError, KeyError, TypeError) as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e),
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e),
http_status=status.HTTP_404_NOT_FOUND)
return response
def get(self, request, note_id):
"""
:param note_id: get note using note id
:param request: user request for fetching all notes created by requested user
:return: smd response
"""
try:
user_redis_note = redis_db.hget(str(request.user.id) + 'note', note_id)
logger.info("fetch data from redis cache" + ' for %s', request.user)
# pdb.set_trace()
if user_redis_note is None:
logger.info('data not present in redis cache' + ' for %s', request.user)
get_note = FundooNote.objects.filter(id=note_id, user_id=request.user.id)
if len(get_note) == 0:
raise ValueError('Id details not present in your database')
logger.info('fetch data from note serialize model' + ' for %s', request.user)
note_data = NotesSerializer(get_note, many=True)
try:
if len(note_data.data) > 0:
note_data.data[0]['label'] = [Label.objects.get(id=x).name
for x in note_data.data[0]['label']]
note_data.data[0]['collaborate'] = [User.objects.get(id=x).email
for x in note_data.data[0]['collaborate']]
except (ValueError, Exception) as e:
raise ValueError(e)
user_redis_note = {k: v for k, v in note_data.data[0].items()}
logger.info('insert note data into redis cache' + ' for %s', request.user)
redis_db.hmset(str(get_note.values()[0]['user_id']) + 'note',
{get_note.values()[0]['id']: user_redis_note})
response = servicesnote.smd_response(success=True, message='following is your note of given note id',
data=[user_redis_note],
http_status=status.HTTP_200_OK)
else:
user_redis_note = ast.literal_eval(user_redis_note.decode('utf-8'))
response = servicesnote.smd_response(success=True, message='following is your note of given note id',
data=[user_redis_note],
http_status=status.HTTP_200_OK)
except ValueError as e:
logger.error('database error' + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def get_queryset(self):
try:
queryset_list = FundooNote.objects.filter(user_id=self.request.user.id)
logger.info("pagination api")
return queryset_list
except (ValueError, KeyError, TypeError, Exception) as e:
logger.error(e)
return servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
def post(self, request):
"""
:param request: take user email address for sending reset password link
:return:
"""
# todo use body in place of request.data : DONE (but now i am using serializer)
# pdb.set_trace()
try:
serialized_data = ForgotPasswordSerializer(data=request.data)
if not 'email' in serialized_data.initial_data:
logger.error('email field not present')
raise KeyError('email field not present')
if serialized_data.is_valid():
email = serialized_data.data['email']
# data = json.loads(request.body)
# print(data['email'])
# email = data['email']
if not util.valid_email(email):
logger.error('Invalid Email')
raise ValueError('Email address is not valid')
if not User.objects.filter(email=email).exists():
logger.error('Email does not exist.')
raise ValueError('You are not register user!')
mail_subject = 'Reset your Password account.'
payload = {'email': email}
jwt_token = util.create_token(payload)
mail_url = get_surl(jwt_token)
short_token = mail_url.split("/")
# todo not use underscore in url : DONE
mail_url = request.build_absolute_uri(
reverse('userlogin:resetpassword', kwargs={'token': short_token[2]}))
ee.emit('messageEvent', mail_subject, email, mail_url)
response = util.smd_response(success=True, message='Check your mail and reset your password',
http_status=status.HTTP_200_OK)
logger.info('password link send on email')
else:
logger.error('ForgotPasswordSerializer serializer data not valid')
response = util.smd_response(message='serializer data not valid',
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as exception_detail:
response = util.smd_response(message=str(exception_detail),
http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request):
"""
:param request: username and password for login
:return: if username and password is correct then response login success other wise give error
"""
# pdb.set_trace()
# Todo creaate requred validation : DONE
try:
serialized_data = LoginSerializer(data=request.data)
if not 'username' in serialized_data.initial_data or not 'password' in serialized_data.initial_data:
logger.error('username or password field not present')
raise EnvironmentError('username or password field not present')
if not serialized_data.is_valid():
logger.error('LoginSerializer serialized data not valid')
raise ValueError('please enter valid', [k for k in serialized_data.errors.keys()])
username = serialized_data.data['username']
password = serialized_data.data['password']
if username == "" or password == "":
logger.error("Username/password Field should not be empty.")
raise KeyError('Username/password should not be empty')
# authenticate username and password valid or not
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
payload = {"username": username, 'password': password}
jwt_token = util.token_encode(payload)
# print(util.token_encode(payload))
# set token in redis cache
redis.redis_db.set(username, jwt_token)
# todo all small latter : DONE
response = util.smd_response(success=True, message="You are successfully login",
data={'access': jwt_token},
http_status=status.HTTP_201_CREATED)
logger.info('user successful login.')
else:
logger.error('Incorrect credential')
response = util.smd_response(message="Incorrect credential",
http_status=status.HTTP_400_BAD_REQUEST)
except Exception as exception_detail:
response = util.smd_response(message=str(exception_detail), http_status=status.HTTP_400_BAD_REQUEST)
return response
def home(request):
"""
:param request: request for share data on social links
:return:
"""
try:
url = request.build_absolute_uri()
return render(request, 'home.html', {'link': url})
except:
return util.smd_response(message='something is wrong', http_status=status.HTTP_404_NOT_FOUND)
def social_login(request):
"""
:param request: social login request with user social profile
:return: render on social login page
"""
# pdb.set_trace()
try:
logger.info('social login')
url = request.build_absolute_uri(reverse('userlogin:login'))
return render(request, 'login.html', {'link': url})
except:
return util.smd_response(message='something is wrong', http_status=status.HTTP_404_NOT_FOUND)
def put(self, request, label_id):
"""
:param request: client request for delete label
:param label_id: delete by label id
:return: return response
"""
try:
put_serializer = LabelSerializer(data=request.data)
if not 'name' in put_serializer.initial_data:
logger.error("name field not exist in Label serializer" + ' for %s', request.user)
raise KeyError("name field not exist in Label serializer")
if put_serializer.is_valid():
user_id = request.user.id
if Label.objects.filter(user_id=user_id, id=label_id).exists():
get_label = Label.objects.get(id=label_id, user_id=request.user.id)
get_label.name = put_serializer.data['name']
get_label.save()
redis_db.hmset(str(user_id) + 'label', {label_id: put_serializer.data['name']})
response = servicesnote.smd_response(success=True, message='Label successfully Updated',
http_status=status.HTTP_200_OK)
logger.info("Label successfully updated" + ' for %s', request.user)
else:
logger.error('Label does not exist in database.' + ' for %s', request.user)
response = servicesnote.smd_response(message='label not valid',
http_status=status.HTTP_400_BAD_REQUEST)
else:
logger.error('Label serializer not valid' + ' for %s', request.user)
response = servicesnote.smd_response(message='label not valid',
http_status=status.HTTP_400_BAD_REQUEST)
except KeyError as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request):
"""
:param request: request file details which user need to post
:return: response in smd format
"""
# pdb.set_trace()
# todo use key for user : DONE (key is user_id)
try:
# file_serialize = UploadSerializer(data=request.data)
file_serialize = UploadSerializer(data=request.data)
if file_serialize.is_valid():
file_serialize.save(user_id=request.user.id)
response = util.smd_response(success=True, message='You file is successfully uploaded',
data={'image_url': file_serialize.data['image']},
http_status=status.HTTP_201_CREATED)
logger.info('file uploaded')
else:
logger.error('UploadSerializer serializer data not valid')
response = util.smd_response(message='file not uploaded', http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(e)
response = util.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
return response
def delete(self, request, note_id):
"""
:param request: request for delete the note created by authenticated user
:param note_id: check credentials by note_id
:return: return response
"""
try:
try:
get_label = FundooNote.objects.get(id=note_id, user_id=request.user.id)
except FundooNote.DoesNotExist as e:
logger.error(str(e) + ' for %s', request.user)
raise ValueError(e)
get_label.delete()
redis_db.hdel(str(request.user.id) + 'note', note_id)
response = servicesnote.smd_response(success=True, message='note is successfully deleted',
http_status=status.HTTP_204_NO_CONTENT)
logger.info('Note deleted of respective id' + ' for %s', request.user)
except ValueError as e:
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request, token):
"""
:param token:
:param request: take the user input as username, password and confirm password
:return: if user name is exist then send response password set successfully
other wise print error message
"""
# todo try re lib. most of time (TRY : DONE)
try:
# todo not(avoid) use number in variable : DONE
try:
surl_token = ShortURL.objects.get(surl=token)
decoded_token = util.decode_token(surl_token.lurl)
user = User.objects.get(email=list(decoded_token.values())[0])
except:
raise ValueError('Invalid token')
password = request.data['password']
confirm_password = request.data['confirm_password']
if password != confirm_password:
logger.error('password not match')
raise Exception('Your password does not match!')
elif not util.password_validator(password):
logger.error('short password length')
raise ValueError('Minimum required 5 characters')
user.set_password(password)
user.save()
response = util.smd_response(success=True, message='Your password is successfully update',
http_status=status.HTTP_201_CREATED)
logger.info('password update successfully')
except Exception as exception_detail:
logger.error('Invalid token')
response = util.smd_response(message=str(exception_detail), http_status=status.HTTP_400_BAD_REQUEST)
return response
def post(self, request):
"""
:param request: user request for send information for register the user
request parameters are username, email and password
:return: we send a activation link on user given mail if user input is valid
"""
# check user enter any empty field or not if any field is empty then give error
try:
serialized_data = RegistrationSerializer(data=request.data)
if not 'username' in serialized_data.initial_data or not 'password' in serialized_data.initial_data or \
not 'email' in serialized_data.initial_data:
logger.error("username/password/email field is not present")
raise KeyError('username and password field is not present')
if not serialized_data.is_valid():
logger.error('RegistrationSerializer data is not valid.')
raise ValueError('please enter valid', [k for k in serialized_data.errors.keys()])
username = serialized_data.initial_data['username']
email = serialized_data.initial_data['email']
password = serialized_data.initial_data['password']
if username == "":
logger.error('Empty username field')
raise ValueError("Error :username field should not be empty.")
elif email == "":
logger.error('Empty email field')
raise ValueError("Error :email field should not be empty.")
elif password == "":
logger.error('Empty password field')
raise ValueError("Error :password field should not be empty.")
elif not util.password_validator(password):
logger.error('password length is short.')
raise ValueError("Error :password should be at least 5 character's")
elif not util.valid_email(email):
logger.error('Email is not valid')
raise ValueError("Email is not valid")
# if all user input data is correct then create user profile with given name, email and password and
# then save in database
user = User.objects.create_user(username=username, email=email, password=password, is_active=False)
user.save()
# create jwt token this token is in byte form therefor we decode and convert into string format
payload = {
user.username: user.email
}
jwt_token = util.create_token(payload)
mail_url = get_surl(jwt_token)
short_token = mail_url.split("/")
mail_subject = 'Activate your account'
# Todo request schema for reverse url : DONE
# print(request.build_absolute_uri(reverse('userlogin:activate', kwargs={'token': short_token[2]})))
mail_url = request.build_absolute_uri(reverse('userlogin:activate', kwargs={'token': short_token[2]}))
ee.emit('messageEvent', mail_subject, email, mail_url)
response = util.smd_response(success=True, message='You are successfully registered',
http_status=status.HTTP_201_CREATED)
logger.info('User successfully registered')
except (KeyError, ValueError) as error:
response = util.smd_response(message=str(error), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as exception_detail:
logger.error(exception_detail)
response = util.smd_response(message=str(exception_detail), http_status=status.HTTP_404_NOT_FOUND)
return response
def post(self, request):
"""
:param request: user request for create fundoo note
:return: smd response
"""
try:
note_data = NotesSerializer(data=request.data, partial=True)
user = request.user
global labels, collaborate, label_flag, collaborate_flag
label_flag, collaborate_flag = False, False
# pdb.set_trace()
if len(note_data.initial_data) == 0:
logger.error("field not present" + ' for %s', request.user)
raise KeyError('one field should be present')
if 'label' in note_data.initial_data:
labels = note_data.initial_data['label']
label_flag = True
# =====================================================
filter_lables = Label.objects.filter(user_id=user.id, name__in=[x for x in labels])
print(filter_lables)
print(len(labels), len(filter_lables))
if len(labels) == len(filter_lables):
note_data.initial_data['label'] = [filter_lables[b].id for b in range(len(filter_lables))]
else:
raise ValueError('Label name not found in Label model')
if 'collaborate' in note_data.initial_data:
collaborate = note_data.initial_data['collaborate']
collaborate_flag = True
# ==========================================================
yy = User.objects.filter(email__in=[x for x in collaborate])
print(yy)
if len(collaborate) == len(yy):
note_data.initial_data['collaborate'] = [yy[b].id for b in range(len(yy))]
else:
raise ValueError("this email not present in database")
if note_data.is_valid():
saved_note_data = note_data.save(user_id=user.id)
if label_flag:
note_data.initial_data['label'] = labels
if collaborate_flag:
note_data.initial_data['collaborate'] = collaborate
redis_db.hmset(str(saved_note_data.user_id) + 'note', {saved_note_data.id: note_data.initial_data})
response = servicesnote.smd_response(success=True, message='Your note is successfully created',
http_status=status.HTTP_201_CREATED)
logger.info('Your note is successfully created' + ' for %s', request.user)
else:
logger.error('Note serializer data not valid' + ' for %s', request.user)
response = servicesnote.smd_response(message='something is wrong',
data=['Please enter correct ' + str(
[x for x in note_data.errors.keys()])],
http_status=status.HTTP_400_BAD_REQUEST)
except (KeyError, ValueError, TypeError) as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(str(e) + ' for %s', request.user)
response = servicesnote.smd_response(message=str(e), http_status=status.HTTP_404_NOT_FOUND)
return response
