from rest_framework import viewsets, status, views from rest_framework.decorators import action import random import logging from django.contrib.auth import authenticate, login from guardian.models import Guardian from junior.models import Junior from account.models import UserProfile, UserPhoneOtp, UserEmailOtp from django.contrib.auth.models import User from .serializers import (SuperUserSerializer, GuardianSerializer, JuniorSerializer, EmailVerificationSerializer, ForgotPasswordSerializer, ResetPasswordSerializer, ChangePasswordSerializer, GoogleSignInSerializer, UpdateGuardianImageSerializer, UpdateJuniorProfileImageSerializer) from rest_framework_simplejwt.tokens import RefreshToken from base.messages import ERROR_CODE, SUCCESS_CODE from guardian.tasks import generate_otp from django.conf import settings from account.utils import send_otp_email from account.utils import custom_response, custom_error_response from django.core.mail import EmailMessage from django.core.mail import send_mail from rest_framework.response import Response from rest_framework.permissions import IsAuthenticated from templated_email import send_templated_mail # class GoogleLoginAPIViewset(viewsets.ModelViewSet): # """Google Login""" # serializer_class = GoogleSignInSerializer # # def create(self, request, *args, **kwargs): # """ # Override default behaviour of create method # """ # provider_type = [] # serializer = self.get_serializer(data=request.data) # if serializer.is_valid(raise_exception=True): # # provider = self.get_provider_view(request.data.get('provider')) # # if User is not authenticated then send error message # # if not provider.is_authenticated(request): # # return custom_error_response({}, status.HTTP_400_BAD_REQUEST) # # user = serializer.save() # if User.objects.filter(email__iexact=user.email).exists(): # print("ppppppppppppp") # return custom_response(SUCCESS_CODE["3003"], response_status=status.HTTP_200_OK) # return custom_response(ERROR_CODE["2002"], response_status=status.HTTP_400_BAD_REQUEST) class UpdateProfileImage(views.APIView): permission_classes = [IsAuthenticated] def put(self, request, format=None): if request.data['user_type'] == '1': junior_query = Junior.objects.filter(auth=request.user).last() serializer = UpdateJuniorProfileImageSerializer(junior_query, data=request.data, partial=True) else: guardian_query = Guardian.objects.filter(user=request.user).last() serializer = UpdateGuardianImageSerializer(guardian_query, data=request.data, partial=True) if serializer.is_valid(): serializer.save() return custom_response(SUCCESS_CODE['3017'], serializer.data, response_status=status.HTTP_200_OK) return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) class ChangePasswordAPIView(views.APIView): permission_classes = [IsAuthenticated] def post(self, request): serializer = ChangePasswordSerializer(context=request.user, data=request.data) if serializer.is_valid(): serializer.save() return custom_response(SUCCESS_CODE['3007'], response_status=status.HTTP_200_OK) return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) class ResetPasswordAPIView(views.APIView): def post(self, request): serializer = ResetPasswordSerializer(data=request.data) if serializer.is_valid(): serializer.save() return custom_response(SUCCESS_CODE['3006'], response_status=status.HTTP_200_OK) return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) class ForgotPasswordAPIView(views.APIView): def post(self, request): serializer = ForgotPasswordSerializer(data=request.data) if serializer.is_valid(): email = serializer.validated_data['email'] try: User.objects.get(email=email) except User.DoesNotExist: return custom_error_response(ERROR_CODE['2004'], response_status=status.HTTP_404_NOT_FOUND) verification_code = ''.join([str(random.randrange(9)) for _ in range(6)]) # Send the verification code to the user's email from_email = settings.EMAIL_HOST_USER recipient_list = [email] send_templated_mail( template_name='email_reset_verification.email', from_email=from_email, recipient_list=recipient_list, context={ 'verification_code': verification_code } ) user_data, created = UserEmailOtp.objects.get_or_create(email=email) if user_data: user_data.otp = verification_code user_data.save() return custom_response(SUCCESS_CODE['3015'], response_status=status.HTTP_200_OK) return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) class SendPhoneOtp(viewsets.ModelViewSet): """Send otp on phone""" def create(self, request, *args, **kwargs): otp = generate_otp() phone_number = self.request.data['phone'] if phone_number.isdigit() and len(phone_number) == 10: phone_otp, created = UserPhoneOtp.objects.get_or_create(country_code=self.request.data['country_code'], phone=self.request.data['phone']) if phone_otp: phone_otp.otp = otp phone_otp.save() return custom_response(None, {'phone_otp':otp}, response_status=status.HTTP_200_OK) return custom_error_response(ERROR_CODE['2020'], response_status=status.HTTP_400_BAD_REQUEST) class UserPhoneVerification(viewsets.ModelViewSet): """Send otp on phone""" def list(self, request, *args, **kwargs): try: phone_data = UserPhoneOtp.objects.filter(phone=self.request.GET.get('phone'), otp=self.request.GET.get('otp')).last() if phone_data: phone_data.is_verified = True phone_data.save() return custom_response(SUCCESS_CODE['3012'], response_status=status.HTTP_200_OK) else: return custom_error_response(ERROR_CODE["2008"], response_status=status.HTTP_400_BAD_REQUEST) except Exception: return custom_error_response(ERROR_CODE["2008"], response_status=status.HTTP_400_BAD_REQUEST) class UserLogin(viewsets.ViewSet): @action(methods=['post'], detail=False) def login(self, request): username = request.data.get('username') password = request.data.get('password') user = authenticate(request, username=username, password=password) try: if user is not None: login(request, user) guardian_data = Guardian.objects.filter(user__username=username, is_complete_profile=True).last() if guardian_data: serializer = GuardianSerializer(guardian_data) junior_data = Junior.objects.filter(auth__username=username, is_complete_profile=True).last() if junior_data: serializer = JuniorSerializer(junior_data) return custom_response(SUCCESS_CODE['3003'], serializer.data, response_status=status.HTTP_200_OK) else: return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_401_UNAUTHORIZED) except Exception as e: logging.error(e) user_profile_data = UserProfile.objects.filter(user__username=username).last() email_verified = UserEmailOtp.objects.filter(email=username).last() refresh = RefreshToken.for_user(user) access_token = str(refresh.access_token) data = {"auth_token":access_token, "is_profile_complete": False, "user_role": user_profile_data.user_type, } is_verified = False if email_verified: is_verified = email_verified.is_verified if not is_verified: otp = generate_otp() email_verified.otp = otp email_verified.save() data.update({"email_otp":otp}) return custom_response(ERROR_CODE['2024'], {"email_otp": otp, "is_email_verified": is_verified}, response_status=status.HTTP_200_OK) data.update({"is_email_verified": is_verified}) return custom_response(None, data, response_status=status.HTTP_200_OK) @action(methods=['post'], detail=False) def admin_login(self, request): username = request.data.get('username') password = request.data.get('password') user = authenticate(request, username=username, password=password) try: if user is not None: login(request, user) if user.is_superuser: serializer = SuperUserSerializer(user) return custom_response(SUCCESS_CODE['3003'], serializer.data, response_status=status.HTTP_200_OK) else: return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_401_UNAUTHORIZED) except Exception as e: logging.error(e) refresh = RefreshToken.for_user(user) access_token = str(refresh.access_token) data = {"auth_token": access_token, "user_role": '3'} return custom_response(None, data, response_status=status.HTTP_200_OK) class UserEmailVerification(viewsets.ModelViewSet): """User Email verification""" serializer_class = EmailVerificationSerializer def list(self, request, *args, **kwargs): try: user_obj = User.objects.filter(username=self.request.GET.get('email')).last() email_data = UserEmailOtp.objects.filter(email=self.request.GET.get('email'), otp=self.request.GET.get('otp')).last() if email_data: email_data.is_verified = True email_data.save() refresh = RefreshToken.for_user(user_obj) access_token = str(refresh.access_token) return custom_response(SUCCESS_CODE['3011'], {"auth_token":access_token}, response_status=status.HTTP_200_OK) else: return custom_error_response(ERROR_CODE["2008"], response_status=status.HTTP_400_BAD_REQUEST) except Exception as e: logging.error(e) return custom_error_response(ERROR_CODE["2008"], response_status=status.HTTP_400_BAD_REQUEST) class ReSendEmailOtp(viewsets.ModelViewSet): """Send otp on phone""" def create(self, request, *args, **kwargs): otp = generate_otp() if User.objects.filter(email=request.data['email']): email_data, created = UserEmailOtp.objects.get_or_create(email=request.data['email']) if email_data: email_data.otp = otp email_data.save() send_otp_email(request.data['email'], otp) return custom_response(SUCCESS_CODE['3016'], response_status=status.HTTP_200_OK) else: return custom_error_response(ERROR_CODE["2023"], response_status=status.HTTP_400_BAD_REQUEST)