def get(self, request, id, *args, **kwargs):
"""
:param request: request for get the particular Actor Details
:param id: Here, we pass an ID for update of a specific Actor Object
:return: It will get a requested Actor with ID from the Database
"""
try:
# import pdb
# pdb.set_trace()
actor_data = Actor.objects.filter(id=id)
if actor_data:
serializer = ActorSerializer(actor_data, many=True)
logger.info("Successfully Read Actor Details")
smd = SMD_Response(
status=True,
message="Successfully Get the Requested Actor Details",
data=[serializer.data])
logger.info('Successfully Get Actor Details')
return Response(smd, status=status.HTTP_200_OK)
else:
logger.error("No data available/invalid id")
smd = SMD_Response(status=False,
message="No Content Available",
data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False, message="Something Went Wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def post(self, request):
"""
:param request:user request for POST
:return: the requested note
"""
try:
title = request.data['title']
if title:
note = NotesDocument.search().query("match", title=title)
serializer = NoteSerializer(note.to_queryset(), many=True)
if serializer:
logger.info("Successfully Found Note")
return Response(SMD_Response(
status=True,
message="Successfully Found the Note",
data=[serializer.data]),
status=status.HTTP_200_OK)
else:
logger.error("Please Provide Valid DATA")
return Response(
SMD_Response(message="Please Provide Valid Data"),
status=status.HTTP_400_BAD_REQUEST)
else:
logger.info("Title Not Found")
return Response(SMD_Response(message="Title Not Found"),
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.error("Something Went Wrong " + str(e))
return Response(SMD_Response(message="Something Went Wrong"),
status=status.HTTP_400_BAD_REQUEST)
def wrapper_function(request, *args, **kwargs):
try:
# import pdb
# pdb.set_trace()
token = redis_cache.Get('Token')
details = TokenGeneration.decode_token(token)
User = get_user_model()
user = User.objects.get(id=details['id'])
if user:
return any_function(request, *args, **kwargs)
else:
smd = SMD_Response(
message="Something Went Wrong, Please Login Again")
return HttpResponse(json.dumps(smd),
status=status.HTTP_404_NOT_FOUND)
except DecodeError:
smd = SMD_Response(status=False, message="Invalid Token", data=[])
return HttpResponse(json.dumps(smd),
status=status.HTTP_401_UNAUTHORIZED)
except Exception:
smd = SMD_Response(
message="Something went wrong(INVALID TOKEN or Details"
", Please provide Token and Login Again!!!!!")
return HttpResponse(json.dumps(smd),
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:param request: Here we get the post request
:return:This api view return token of the logged in user
"""
try:
# import pdb
# pdb.set_trace()
username = request.data['username']
password = request.data['password']
user = authenticate(username=username, password=password)
if user is not None and user != '':
token = TokenGeneration.encode_token(self, user)
Token = 'Token'
redis_cache.Set(Token, token)
smd = SMD_Response(True, "You have Logged in successfully!!!", data=[token])
return Response(smd, status=status.HTTP_202_ACCEPTED)
else:
smd = SMD_Response(False, "Please Enter Valid Credentials", data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(False, "Login Failed!!!", data=[])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:param-Here image is using for uploading into the AWS s3-bucket
:request-by using Secret Key and Bucket Storage name uploading the image into the S3-Bucket
:return-successfully image uploaded into the S3-Bucket
"""
try:
# import pdb
# pdb.set_trace()
serializer = ImageSerializer(data=request.data)
if serializer.is_valid():
user = get_user(request)
exist_image = Fundoo.objects.get(id=user.id)
if exist_image:
filee = request.data['upload']
up = CloudUpload()
url = f'https://{settings.AWS_STORAGE_BUCKET_NAME}.s3-{settings.AWS_LOCATION}.amazonaws.com/{filee}'
up.upload_image(filee)
exist_image.upload = url
exist_image.save()
smd = SMD_Response(status=True, message="Successfully Uploaded Image to S3 BUCKET."
"Please go to your AWS Account and "
"see image in your bucket having url")
else:
smd = SMD_Response(message="Please Enter a Valid Image",
status=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="something went wrong, Image not uploaded successfully...")
return Response(json.dumps(smd))
def delete(self, request, id, *args, **kwargs):
"""
:param request:Request for Delete Movie Details
:param id: Here, we pass a ID for deleting requested Movie ID
:return: This function delete the requested Movie Details from the DATABASE
"""
try:
movie_obj = Movie.objects.filter(id=id)
if movie_obj:
movie_obj.delete()
logger.info("Movie Details Deleted")
return Response(SMD_Response(
status=True,
message="Successfully Deleted the Movie Details"),
status=status.HTTP_204_NO_CONTENT)
else:
logger.error("Please provide valid details")
smd = SMD_Response(message="Not found such Detail")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message="Not a VALID ID or Something went wrong!!"),
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
"""
:param request: Request for getting all the actor details
:return: the details of all actors
"""
try:
all_actors = Actor.objects.all()
if all_actors:
serializer = ActorSerializer(all_actors, many=True)
logger.info(
"Successfully get the actor details from the database")
smd = SMD_Response(
status=True,
message=
"Successfully get the actor details from the database",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("No data available to be fetch from DATABASE")
smd = SMD_Response(status=False,
message="No Content Available")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("Something went wrong-" + str(e))
smd = SMD_Response(message="Something went wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def delete(self, request, id, *args, **kwargs):
"""
:param request: User Request for Delete a LABEL
:param id: Here, we pass an ID for deleting requested ID
:return: This function delete the requested label from the DATABASE
"""
try:
label_user = get_user(request)
if label_user:
label = Label.objects.get(id=id, user_id=label_user.id)
if label is not None:
label.delete()
logger.info("Label Deleted")
label_update_in_redis(label_user)
return Response(SMD_Response(
status=True, message="Successfully Deleted the Label"),
status=status.HTTP_204_NO_CONTENT)
else:
logger.error("Please provide valid details")
smd = SMD_Response(message="Not found such Label")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message="Not a VALID ID/Invalid Token or Something went wrong!!"
),
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
"""
:param request: request the details of an actor
:return: save the details of an actor in database
"""
try:
serializer = ActorSerializer(data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
logger.info(
"Successfully Save the actor details in the database")
smd = SMD_Response(
status=True,
message=
"Successfully Save the actor details in the database",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Please Provide Valid Details")
smd = SMD_Response(status=False,
message="Please Provide Valid Details",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something went wrong-" + str(e))
smd = SMD_Response(message="Something Went Wrong")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, ResetUser):
"""
:param request: Here we get the post request
:param ResetUser: It is the user who wants to reset the password
:return: Successfully change the password and save it in the DATABASE
"""
try:
User = get_user_model()
user = User.objects.get(username=ResetUser)
if user:
password = request.data['password']
confirm_password = request.data['confirm_password']
if password == confirm_password:
user.set_password(password)
user.save()
smd = SMD_Response(status=True, message="Password Set SuccessFully")
return Response(smd, status=status.HTTP_200_OK)
else:
smd = SMD_Response(message="Password and Confirm Password did not match")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
smd = SMD_Response(status=False, message="User does not exist!!!")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(status=False, message="Reset Password Failed!!!")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, id, *args, **kwargs):
"""
:param request: User add a collaborator to the note
:return: update the database with collaborator
"""
try:
# import pdb
# pdb.set_trace()
collaborator_user = get_user(request)
if collaborator_user:
note = Note.objects.get(id=id, user_id=collaborator_user.id)
if note is not None:
data = request.data
if 'collaborator' in data:
collaborator_list = []
collaborators = data['collaborator']
for mail in collaborators:
user = User.objects.filter(email=mail)
if user:
for usr in user:
collaborator_list.append(usr.id)
else:
logger.error("Invalid Format or Details!!!")
return Response(
SMD_Response(
message="Something went wrong when "
"validating your collaborator"))
data['collaborator'] = collaborator_list
serializer = CollaboratorSerializer(note, data=data)
if serializer.is_valid():
serializer.save()
update_redis(collaborator_user)
logger.info("Successfully Collaborator Added")
smd = SMD_Response(
status=True,
message="Successfully Added Collaborator",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Invalid Format or Details!!!")
smd = SMD_Response(
status=True,
message="Collaborator Addition Failed",
data=[serializer.errors])
return Response(smd,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False, message="Something Went Wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def post(self, request, *args, **kwargs):
"""
:param request: request the movie details
:return: save the details of a movie in database
"""
try:
# import pdb
# pdb.set_trace()
data = request.data
if 'actor' in data:
actor_list = []
actors = data['actor']
for name in actors:
obj = Actor.objects.get(actor_name=name)
if obj:
actor_list.append(obj.id)
else:
return Response(
SMD_Response(message="Something went wrong when"
"while adding actors"))
data['actor'] = actor_list
if 'producer' in data:
producer_list = []
producers = data['producer']
for name in producers:
obj = Producer.objects.get(producer_name=name)
if obj:
producer_list.append(obj.id)
else:
return Response(
SMD_Response(message="Something went wrong when"
"while adding producers"))
data['producer'] = producer_list
serializer = MovieSerializer(data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
logger.info(
"Successfully Save the movie details in the database")
smd = SMD_Response(
status=True,
message=
"Successfully Save the movie details in the database",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Please Provide Valid Details")
smd = SMD_Response(status=False,
message="Please Provide Valid Details",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something went wrong-" + str(e))
smd = SMD_Response(message="Something Went Wrong")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
"""
:param request:User request for getting all the notes
:return:All the Notes belongs to the Logged In User
"""
try:
# import pdb
# pdb.set_trace()
note_user = get_user(request)
if note_user:
note_data = redis_cache.Get(note_user.username + ' notes')
if note_data:
notes = pickle.loads(note_data)
serializer = NoteSerializer(notes, many=True)
logger.info("Successfully Read Notes from REDIS")
smd = SMD_Response(
status=True,
message="Successfully Read Notes from REDIS",
data=[serializer.data])
logger.info('Successfully Get notes from Redis')
return Response(smd, status=status.HTTP_200_OK)
else:
all_notes = Note.objects.filter(user_id=note_user.id,
is_archive=False,
is_trashed=False)
if all_notes:
serializer = NoteSerializer(all_notes, many=True)
# notes = pickle.dumps(all_notes)
update_redis(note_user)
smd = SMD_Response(
status=True,
message="Successfully Read Notes from Database",
data=[serializer.data])
logger.info('successfully get notes from database')
return Response(smd, status=status.HTTP_200_OK)
else:
logger.error(
"No data available to be fetch from Redis and in DATABASE"
)
smd = SMD_Response(status=False,
message="No Content Available")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False,
message="Something went wrong",
data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def get(self, request, *args, **kwargs):
"""
:param request:User request for getting all the Labels
:return:All the Labels belongs to the Logged In User
"""
try:
# import pdb
# pdb.set_trace()
label_user = get_user(request)
if label_user:
label_data = redis_cache.Get(label_user.username + ' labels')
if label_data:
labels = pickle.loads(label_data)
serializer = LabelSerializer(labels, many=True)
logger.info("Successfully Read Labels from Redis")
smd = SMD_Response(
status=True,
message="Successfully Read Labels from Redis",
data=[serializer.data])
logger.info('successfully get labels from redis')
return Response(smd, status=status.HTTP_200_OK)
else:
all_labels = Label.objects.filter(user_id=label_user.id)
if all_labels:
serializer = LabelSerializer(all_labels, many=True)
label_update_in_redis(label_user)
smd = SMD_Response(
status=True,
message="Successfully Read Labels from Database",
data=[serializer.data])
logger.info('successfully get labels from database')
return Response(smd, status=status.HTTP_200_OK)
else:
logger.error(
"No data available to be fetch from Redis")
smd = SMD_Response(status=False,
message="No Content Available",
data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False, message="Something went wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def put(self, request, id, *args, **kwargs):
"""
:param request:User request for put(update) the LABEL operation
:param id:Here, we pass an ID for update of a specific Label
:return:It will Update a requested Label in Database
"""
try:
# import pdb
# pdb.set_trace()
label_user = get_user(request)
if label_user:
label = Label.objects.get(id=id, user_id=label_user.id)
if label is not None:
data = request.data
serializer = LabelSerializer(label, data=data)
if serializer.is_valid():
serializer.save()
label_update_in_redis(label_user)
logger.info("Successfully Updated the label")
smd = SMD_Response(
status=True,
message="Label Successfully Updated",
data=[serializer.data])
return Response(smd, status=status.HTTP_202_ACCEPTED)
else:
logger.error("Please provide valid details")
smd = SMD_Response(
message="Invalid Request/No such query exist",
data=[serializer.errors])
return Response(smd,
status=status.HTTP_400_BAD_REQUEST)
else:
logger.info("No DATA Present")
return Response(
SMD_Response(message="No Data Present in Label"),
status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message="Please Provide a Valid ID/Valid token or "
"Something Went Wrong"),
status=status.HTTP_400_BAD_REQUEST)
def activate(request, token):
"""
:param request: here we use get request
:param token:here we get token
:return:in this function we get token when user click the link and we decode the token and
activate the user
"""
try:
import pdb
# pdb.set_trace()
token1 = ShortURL.objects.get(surl=token)
token = token1.lurl
details = TokenGeneration.decode_token(token)
username = details['username']
User = get_user_model()
user = User.objects.get(username=username)
if user is not None:
user.is_active = True
user.save()
# smd = SMD_Response(True, "You have successfully registered", data=[])
return redirect(reverse('login'))
else:
return redirect(reverse('register'))
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(False, "Invalid Token Received", data=[])
return HttpResponse(json.dumps(smd), status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
"""
:param request: Here we got the GET request
:return: It will logout the Logged In user
"""
# import pdb
# pdb.set_trace()
try:
redis_cache.Del('Token')
logout(request)
smd = SMD_Response(status=True, message="Successfully Logged Out")
return Response(smd, status=status.HTTP_200_OK)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="Logged Out Failed")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:param request: we are sending text message to the user
:return: successfully send message to the user
"""
try:
serializer = PhoneSerializer(data=request.data)
if serializer.is_valid():
send = CloudUpload()
send.simple_notification_service(request.data['phone'])
return Response(SMD_Response(status=True, message="Successfully send message",
data=[serializer.data]),
status=status.HTTP_200_OK)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="Something Went Wrong")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
"""
:param request:Request data from a Logged In user by passing a Token
:return:Save the Labels in the database
"""
try:
# import pdb
# pdb.set_trace()
label_user = get_user(request)
if label_user:
data = request.data
data['user'] = str(label_user.id)
if Label.objects.filter(name=data['name'],
user_id=label_user.id).exists():
logger.info("Label already Exists")
else:
serializer = LabelSerializer(data=data)
if serializer.is_valid():
serializer.save()
label_update_in_redis(label_user)
logger.info("Successfully Note Created")
smd = SMD_Response(
status=True,
message="Successfully Label Created",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Invalid Format or Details!!!")
smd = SMD_Response(status=True,
message="Label Creation Failed",
data=[serializer.errors])
return Response(smd,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False, message="Something Went Wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def get(self, request, *args, **kwargs):
"""
:param request:User request for get all archive notes of LOGGED IN User
:return:This function return all the archive notes of LOGGED IN user
"""
try:
# import pdb
# pdb.set_trace()
archive_notes_user = get_user(request)
if archive_notes_user:
archive_note_data = redis_cache.Get(
archive_notes_user.username + ' archive_notes')
if archive_note_data is not None:
archive_note = pickle.loads(archive_note_data)
serializer = NoteSerializer(archive_note, many=True)
logger.info("Successfully Get the ARCHIVED Notes")
smd = SMD_Response(status=True,
message="Successfully Note Found",
data=[serializer.data])
return Response(smd, status=status.HTTP_302_FOUND)
else:
logger.error(
"Please provide the valid NOTE Details and Token")
smd = SMD_Response(
status=True,
message=
"No Archive Notes are there for this User_ID EXISTS!!",
data=['NOT FOUND'])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message=
"Not a VALID User/Invalid Token or Something went wrong!!"),
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:purpose: in this function we register a new user via sending jwt token on email
:param request: here we get post request
:return:in this function we take user input for registration and sent mail to email id
"""
try:
# import pdb
# pdb.set_trace()
username = request.data['username']
email = request.data['email']
password = request.data['password']
if password != '':
User = get_user_model()
if User.objects.filter(username=username).exists():
messages.info(request, "Username Already Exists")
smd = SMD_Response(message="Username Already Exists!!Please enter a different username")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
user = User.objects.create_user(username=username, email=email, password=password)
token = TokenGeneration.encode_token(self, user)
surl = get_surl(token)
url = surl.split("/")
message = render_to_string('users/activate.html',
{'user': user.username,
'domain': get_current_site(request).domain,
'token': url[2]})
recipient_list = [email, ]
email_event.emit("Account_Activate_Event", message, recipient_list)
smd = SMD_Response(True, 'Thank You For Registering to our site, '
'Please check mail to activate your account', data=[])
return Response(smd, status=201)
else:
smd = SMD_Response(message="Password is Not Correct")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="Registration Failed")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, id, *args, **kwargs):
"""
:param request: User request for get the particular Note, operation
:param id: Here, we pass an ID for update of a specific Note
:return: It will get a requested Note with ID from the Database
"""
try:
# import pdb
# pdb.set_trace()
label_user = get_user(request)
if label_user:
label_data = Label.objects.filter(id=id, user_id=label_user.id)
if label_data:
serializer = LabelSerializer(label_data, many=True)
logger.info("Successfully Read Notes")
smd = SMD_Response(status=True,
message="Successfully Read Labels",
data=[serializer.data])
logger.info('Successfully Get Labels')
return Response(smd, status=status.HTTP_200_OK)
else:
logger.error("No data available/invalid id or user_id")
smd = SMD_Response(status=False,
message="No Content Available")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False,
message="Something Went Wrong",
data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def access_token(request):
"""
:param request: here we get code from google oauth2
:return:in this function by using the code from the google, we get access token,
and by using that token we get user information after that we get email id of that user
and redirect that user to HOMEPAGE
"""
try:
# import pdb
# pdb.set_trace()
path = request.get_full_path()
code_path = path.split('&')
code = code_path[1].split('=')
code = unquote(code[1])
# print(code)
url = settings.GOOGLE_ACCESS_TOKEN_URI
data = {
"code": code,
"client_id": settings.GOOGLE_OAUTH2_CLIENT_ID,
"client_secret": settings.GOOGLE_OAUTH2_CLIENT_SECRET,
"grant_type": "authorization_code",
"redirect_uri": settings.GOOGLE_REDIRECT_URI
}
response = requests.post(url, data)
token = json.loads(response.text)['access_token']
headers = {'Authorization': 'OAuth %s' % token}
req = requests.get(settings.SOCIAL_AUTH_GET_GOOGLE_INFO, headers=headers)
google_data = req.json()
email_address = google_data['emailAddress']
if email_address is not None:
return redirect(settings.BASE_URL)
else:
smd = SMD_Response(message='Email Address is not Valid')
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response()
return smd
def verify(request, token):
"""
:param request: request for reset password
:param token: here we get token for decoding that the user details, who wants to change the password
:return:this function redirect to the user's forgot password page
"""
try:
token1 = ShortURL.objects.get(surl=token)
token = token1.lurl
details = jwt.decode(token, 'SECRET_KEY', algorithm='HS256')
username = details['username']
User = get_user_model()
user = User.objects.get(username=username)
if user:
user.save()
return redirect(reverse('forgot_password', args=[str(user)]))
else:
smd = SMD_Response(message="User Does Not Exist")
return HttpResponse(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(message="Invalid Details!!!Verification Failed!!!")
return HttpResponse(smd, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, id, *args, **kwargs):
"""
:param request:Request for put(update) the Producer Details
:param id:Here, we pass an ID for update of a requested Producer
:return:It will Update a requested Producer Details in Database
"""
try:
producer_obj = Producer.objects.get(id=id)
if producer_obj is not None:
data = request.data
serializer = ProducerSerializer(producer_obj, data=data)
if serializer.is_valid():
serializer.save()
logger.info(
"Successfully Updated the Details of the Producer")
smd = SMD_Response(
status=True,
message="Producer Details Successfully Updated",
data=[serializer.data])
return Response(smd, status=status.HTTP_202_ACCEPTED)
else:
logger.error("Please provide valid details")
smd = SMD_Response(
message="Invalid Request/No such query exist",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
logger.info("No DATA Present")
return Response(SMD_Response(message="No Data Present"),
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(
SMD_Response(message="Please Provide a Valid ID or "
"Something Went Wrong"),
status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, id, *args, **kwargs):
"""
:param request: User Request for Delete a Note
:param id: Here, we pass a ID for deleting requested ID
:return: This function delete the requested note from the DATABASE
"""
try:
# import pdb
# pdb.set_trace()
note_user = get_user(request)
if note_user:
note = Note.objects.filter(id=id, user_id=note_user.id)
if note:
note.delete()
update_redis(note_user)
logger.info("Note Deleted")
return Response(SMD_Response(
status=True, message="Successfully Deleted the Note"),
status=status.HTTP_204_NO_CONTENT)
else:
logger.error("Please provide valid details")
smd = SMD_Response(message="Not found such Note")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message="Not a VALID ID/Invalid Token or Something went wrong!!"
),
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
:param request: here is post request por set password
:return: in this function we take email from user and send token for verification
"""
try:
username = request.data['username']
email = request.data['email']
User = get_user_model()
user = User.objects.get(username=username, email=email)
if user:
payload = {
'username': user.username,
'email': user.email
}
token = jwt.encode(payload, 'SECRET_KEY', algorithm='HS256').decode('utf-8')
surl = get_surl(token)
url = surl.split('/')
message = render_to_string('users/reset_password.html',
{
'user': user.username,
'domain': get_current_site(request).domain,
'token': url[2]
})
recipient_list = [email, ]
email_event.emit("Reset_Password_Event", message, recipient_list)
smd = SMD_Response(True, 'We have sent an email, '
'please click there on link to reset password', data=[])
return Response(smd, status=status.HTTP_200_OK)
else:
smd = SMD_Response(False, 'Reset Password Process Failed', data=[])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something Went Wrong" + str(e))
smd = SMD_Response(status=False, message="Failed!!!")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
try:
# import pdb
# pdb.set_trace()
remind_user = get_user(request)
if remind_user:
reminder_note = Note.objects.filter(user_id=remind_user.id,
reminder__isnull=False)
serializer = NoteSerializer(reminder_note, many=True)
if reminder_note is not None:
logger.info("Successfully Get the Reminder Notes")
smd = SMD_Response(status=True,
message="Successfully Note Found",
data=[serializer.data])
return Response(smd, status=status.HTTP_302_FOUND)
else:
logger.error(
"Please provide the valid NOTE Details and Token")
smd = SMD_Response(
status=True,
message=
"No Reminder Notes are there for this User_ID EXISTS!!",
data=[serializer.errors])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(SMD_Response(
message=
"Not a VALID User/Invalid Token or Something went wrong!!"),
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
"""
:param request:user request for get pages
:return:this function used for pagination means gives data after request of page
"""
try:
# import pdb
# pdb.set_trace()
note_list = Note.objects.all()
paginator = Paginator(note_list, 4)
page = request.GET.get('page', 1)
notes = paginator.page(page)
except PageNotAnInteger:
notes = paginator.page(1)
except EmptyPage:
notes = paginator.page(paginator.num_pages)
except Exception as e:
logger.error("Something went wrong" + str(e))
smd = SMD_Response()
return HttpResponse(smd, status=status.HTTP_400_BAD_REQUEST)
return render(request, 'fundoonotes/pagination.html', {'notes': notes})
def post(self, request, *args, **kwargs):
"""
:param request:Request data from a Logged In user by passing a Token
:return:Save the Note in the database
"""
try:
# import pdb
# pdb.set_trace()
note_user = get_user(request)
if note_user:
data = request.data
data['user'] = str(note_user.id)
if 'collaborator' in data:
collaborator_list = []
collaborators = data['collaborator']
for mail in collaborators:
user = User.objects.filter(email=mail)
if user:
for usr in user:
collaborator_list.append(usr.id)
else:
return Response(
SMD_Response(
message="Something went wrong when "
"validating your collaborator"))
data['collaborator'] = collaborator_list
if 'label' in data:
label_list = []
labels = data['label']
for name in labels:
user = Label.objects.get(name=name,
user_id=note_user.id)
if user:
label_list.append(user.id)
else:
return Response(
SMD_Response(
message="Something went wrong when"
"validating your label"))
data['label'] = label_list
if 'reminder' in data:
remainder = data['reminder']
rem = datetime.datetime.strptime(remainder,
"%Y-%m-%d %H:%M:%S")
if rem:
data['reminder'] = remainder
else:
return Response(
SMD_Response(
message=
"Does Not match format '%Y-%m-%d %H:%M:%S"))
serializer = NoteSerializer(data=data, partial=True)
if serializer.is_valid():
serializer.save()
update_redis(note_user)
logger.info("Successfully Note Created")
smd = SMD_Response(status=True,
message="Successfully Note Created",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Invalid Format or Details!!!")
smd = SMD_Response(status=True,
message="Note Creation Failed",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(
SMD_Response(
message=
"You Need to LOGIN FIRST and Provide Valid Credentials"
))
except Exception as e:
logger.warning("Something went wrong " + str(e))
smd = SMD_Response(status=False, message="Something Went Wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
