def update_address(self, request):
"""
update the address.
"""
try:
objects = AddressSevice.get_instance(request.user.id,
request.data["id"])
serializer = self.get_serializer(objects, data=request.data)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
user = serializer.save()
if user:
return Response({'detail': 'updated successfully'},
status=status.HTTP_200_OK)
return Response({
'status': 'Failed',
'result': None
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
print(str(e))
raise ParseException(BAD_REQUEST, serializer.errors)
def updaterate(self, request, format='json'):
try:
data = request.data
instance = self.model.objects.get(id=data["id"])
serializer = self.get_serializer(instance, data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
raise ParseException(BAD_REQUEST, serializer.errors)
except self.model.DoesNotExist:
raise ResourceNotFoundException(BAD_REQUEST)
except:
raise ParseException(BAD_REQUEST)
def candidate(self, request):
"""
Returns candidate account creation
"""
serializer = self.get_serializer(data=request.data)
if not serializer.is_valid():
print(serializer.errors)
raise ParseException({'status': 'Incorrect Input'},
serializer.errors)
if Candidate.objects.filter(email=self.request.data['email']).exists():
return Response({"status": "candidate already exists"},
status=status.HTTP_400_BAD_REQUEST)
print("create candidate with", serializer.validated_data)
candidate = serializer.create(serializer.validated_data)
if candidate:
# msg_plain = render_to_string('email_message.txt',{"user":candidate.first_name})
# msg_html = render_to_string('email.html',{"user":candidate.first_name})
# send_mail('Hirool',msg_plain,settings.EMAIL_HOST_USER,[candidate.email],html_message=msg_html,)
return Response({'status': 'Successfully added'},
status=status.HTTP_201_CREATED)
return Response({"status": "Not Found"}, status.HTTP_404_NOT_FOUND)
def get_serializer_class(self):
"""
"""
try:
return self.serializers_dict[self.action]
except KeyError as key:
raise ParseException(BAD_ACTION, errors=key)
def updatecandidatedetail(self, request):
"""
Modify the candidate details.
"""
try:
self.objects = UserDetails.objects.get(user_id=request.user,
id=request.data['id'])
serializer = self.get_serializer(self.objects, data=request.data)
print(serializer.is_valid())
print(serializer.errors)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
user = serializer.save()
print(user)
if user:
return Response({}, status=status.HTTP_200_OK)
except ObjectDoesNotExist as e:
return Response(({
'status': 'Failed',
'result': None,
'message': 'id is not valid'
}),
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response(({
'status': 'Failed',
'result': None,
'message': str(e)
}),
status=status.HTTP_400_BAD_REQUEST)
def resetpassword(self, request):
try:
email = request.data['email']
otp = request.data['otp']
except Exception as e:
return Response(({
'status': 'Failed',
'detail': str(e.args)
}),
status=status.HTTP_400_BAD_REQUEST)
if not User.objects.filter(email=email).exists():
return Response(BAD_REQUEST, status=status.HTTP_400_BAD_REQUEST)
self.objects = User.objects.get(email=email)
if not redis_client.key_exists(email):
return Response(BAD_REQUEST, status=status.HTTP_400_BAD_REQUEST)
# delete existing value in redis.
redis_client.remove_key_data(email)
serializer = self.get_serializer(self.objects, data=request.data)
print(serializer.is_valid())
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
serializer.save()
return Response(({
'status': 'password updated successfully'
}),
status=status.HTTP_200_OK)
def getrate(self, request, format='json'):
try:
input_id = request.GET.get("id")
serializer = self.get_serializer(
self.get_queryset().get(id=input_id))
return Response(serializer.data, status=status.HTTP_200_OK)
except:
raise ParseException(BAD_REQUEST)
def ratelist(self, request, format='json'):
try:
filterdata = request.query_params.dict()
page = self.paginate_queryset(
self.get_queryset(filterdata=filterdata))
serialiser = self.get_serializer(page, many=True)
return self.get_paginated_response(serialiser.data)
except:
raise ParseException(BAD_REQUEST)
def add_status(self, request):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
interview = serializer.create(serializer.validated_data)
if interview:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"status": "error"}, status.HTTP_404_NOT_FOUND)
def rates(self, request):
try:
product_rates = self.model.objects.values('product').annotate(
avg_rate=Avg('rate'),
max_rate=Max('rate'),
min_rate=Min('rate'),
no_of_rates=Count('rate')).order_by("product")
return Response(product_rates)
except:
raise ParseException(BAD_REQUEST)
def rateproduct(self, request, format='json'):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response({"status": "Successfully rated Product"},
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
raise ParseException(BAD_REQUEST, serializer.errors)
def product_rate(self, request):
try:
product = request.GET["product"]
product_rate = self.model.objects.values('product').annotate(
avg_rate=Avg('rate'),
max_rate=Max('rate'),
min_rate=Min('rate'),
no_of_rates=Count('rate')).filter(product=product)
return Response(product_rate)
except:
raise ParseException(BAD_REQUEST)
def get_queryset(cls, user, filter_data=None):
"""
fetching the profile queryset on profile id
"""
queryset = Address.objects.select_related('user').filter(user=user)
if filter_data:
try:
queryset = queryset.filter(**filter_data)
except:
raise ParseException(BAD_REQUEST)
return queryset
def add_address(self, request):
""" adding Address controler"""
try:
data = request.data
data["user"] = request.user.id
serializer = self.get_serializer(data=data)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
user = serializer.save()
if user:
return Response({'status': 'address Created Successfully'},
status=status.HTTP_201_CREATED)
return Response({
'status': 'Failed',
'result': None
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
raise ParseException(BAD_REQUEST, serializer.errors)
def list_address(self, request):
"""
list all my address.
"""
try:
data = self.get_queryset(request.user.id)
page = self.paginate_queryset(data)
serialiser = self.get_serializer(page, many=True)
return self.get_paginated_response(serialiser.data)
except Exception as e:
raise ParseException(BAD_REQUEST, serializer.errors)
def add_permissions(self, request):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
print("create permissions with", serializer.validated_data)
permissions = serializer.create(serializer.validated_data)
if permissions:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"status": "error"}, status.HTTP_404_NOT_FOUND)
def add_leave(self, request):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
print(serializer.errors)
raise ParseException({'status':'Incorrect input'}, serializer.errors)
print("create client with", serializer.validated_data)
leavetracker_obj = serializer.create(serializer.validated_data)
if leavetracker_obj:
return Response({'status':'Successfully added'}, status=status.HTTP_201_CREATED)
return Response({"status": "Not Found"}, status.HTTP_404_NOT_FOUND)
def add_leavetype(self, request):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
print(serializer.errors)
raise ParseException({'status':'Incorrect Input'}, serializer.errors)
leavetype_obj = serializer.create(serializer.validated_data)
if leavetype_obj:
# msg_plain = render_to_string('interview_email_message.txt', {"name":interview.candidate.first_name,"date": interview.date,"location":interview.location})
# msg_html = render_to_string('interview_email.html',{"name":interview.candidate.first_name,"date": interview.date,"location":interview.location})
# send_mail('Hirool', msg_plain, settings.EMAIL_HOST_USER, [interview.candidate.email],html_message=msg_html, )
return Response(serializer.data,status.HTTP_201_CREATED)
return Response({"status": "error"}, status.HTTP_404_NOT_FOUND)
def job(self, request):
"""
Returns jd details
"""
serializer = self.get_serializer(data=request.data)
if not serializer.is_valid():
print(serializer.errors)
raise ParseException(BAD_REQUEST, serializer.errors)
print("create job with", serializer.validated_data)
job_obj = serializer.create(serializer.validated_data)
if job_obj:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"status": "error"}, status.HTTP_404_NOT_FOUND)
def register(self, request):
"""
"""
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
print (serializer.errors)
raise ParseException(BAD_REQUEST, serializer.errors)
print("registering user with", serializer.validated_data)
user = serializer.save()
if user:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'status':'User Created Successfully'}, status.HTTP_200_OK)
def profile_update(self, request):
"""
Return user profile data and groups
"""
try:
data=request.data
d = ProfileSevice.get_instance(request.user.id)
serializer = self.get_serializer(d,data=data)
if not serializer.is_valid():
raise ParseException(BAD_REQUEST, serializer.errors)
serializer.save()
return Response(serializer.data, status.HTTP_200_OK)
except Exception as e:
return Response({"status": str(e)}, status.HTTP_404_NOT_FOUND)
def update_pass(self, request):
"""
update new password with validatig old password
"""
data = request.data
user_obj = User.objects.get(id=request.user.id)
serializer = self.get_serializer(user_obj, data=data)
if not serializer.is_valid():
raise ParseException(BAD_REQUEST, serializer.errors)
try:
if not user_obj.check_password(data.get("old_password")):
return Response({"old_password is Wrong password."}, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response({"status": "Successfully Updated new password"}, status.HTTP_200_OK)
except Exception as e:
return Response({"status": str(e)}, status.HTTP_404_NOT_FOUND)
def addcandidate(self, request):
"""
"""
data = request.data
data = data.copy()
data['user'] = request.user.id
serializer = self.get_serializer(data=data)
print(serializer.is_valid())
if serializer.is_valid() is False:
print(serializer.errors)
raise ParseException(BAD_REQUEST, serializer.errors)
user = serializer.save()
if user:
return Response(serializer.errors, status=status.HTTP_201_CREATED)
return Response(serializer.data, status=status.HTTP_200_OK)
def leave_update(self, request):
"""
Return user profile data and groups
"""
try:
data=request.data
id=data["id"]
serializer=self.get_serializer(self.services.update_leave_service(id),data=request.data)
if not serializer.is_valid():
print(serializer.errors)
raise ParseException({'status':'Incorrect Input'},serializer.errors)
else:
serializer.save()
return Response({"status":"updated Successfully"},status.HTTP_200_OK)
except Exception as e:
raise
return Response({"status":"Not Found"},status.HTTP_404_NOT_FOUND)
def login(self, request):
'''
'''
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
print(serializer.validated_data["password"])
user = authenticate(email=serializer.validated_data["email"],
password=serializer.validated_data["password"])
if not user:
return Response({'error': 'Invalid Credentials'},
status=status.HTTP_404_NOT_FOUND)
token = user.access_token
return Response({'token': token}, status=status.HTTP_200_OK)
def job_update(self,request):
"""
Returns jd edit
"""
try:
data=request.data
id=data["id"]
serializer=self.get_serializer(self.services.update_job_service(id),data=request.data)
if not serializer.is_valid():
print(serializer.errors)
raise ParseException(BAD_REQUEST,serializer.errors)
else:
serializer.save()
return Response({"status":"updated Successfully"},status.HTTP_200_OK)
except Exception as e:
raise
return Response({"status":"Not Found"},status.HTTP_404_NOT_FOUND)
def org(self, request):
"""
Returns clients account creations
"""
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
raise ParseException({'status':'Incorrect input'}, serializer.errors)
if Client.objects.filter(name=self.request.data['name']).exists():
return Response({"status":"Client already exists"},status=status.HTTP_400_BAD_REQUEST)
print("create client with", serializer.validated_data)
client = serializer.create(serializer.validated_data)
if client:
return Response({'status':'Successfully added'}, status=status.HTTP_201_CREATED)
return Response({"status": "Not Found"}, status.HTTP_404_NOT_FOUND)
def register(self, request):
"""
Returns user account creationsm
"""
serializer = self.get_serializer(data=request.data)
if serializer.is_valid() is False:
print(serializer.errors)
raise ParseException({'status':'Incorrect Input'}, serializer.errors)
if User.objects.filter(email=self.request.data['email']).exists():
return Response({"status":"User already exists"},status=status.HTTP_400_BAD_REQUEST)
user = serializer.create(serializer.validated_data)
if user:
# msg_plain = render_to_string('email_message.txt', {"user": user.first_name})
# msg_html = render_to_string('email.html', {"user": user.first_name})
# send_mail('Hirool', msg_plain, settings.EMAIL_HOST_USER, [user.email], html_message=msg_html)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"status": "Not Found"}, status.HTTP_404_NOT_FOUND)
def register(self, request):
serializer = self.get_serializer(data=request.data)
print(serializer.is_valid())
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
try:
user = serializer.save()
except Exception as e:
return Response(({
'status': 'Failed',
'detail': str(e.args)
}),
status=status.HTTP_409_CONFLICT)
if user:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({}, status.HTTP_200_OK)
def register(self, request):
'''
'''
serializer = self.get_serializer(data=request.data)
print(serializer.is_valid())
if serializer.is_valid() is False:
raise ParseException(BAD_REQUEST, serializer.errors)
try:
user = serializer.create(serializer.validated_data)
except Exception as e:
return Response(({
'Failed': str(e)
}),
status=status.HTTP_409_CONFLICT)
if user:
return Response(serializer.validated_data,
status=status.HTTP_201_CREATED)
return Response(serializer.validated_data, status=status.HTTP_200_OK)
