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