class RegisterView(CreateAPIView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
@sensitive_post_parameters_m
def dispatch(self, *args, **kwargs):
return super(RegisterView, self).dispatch(*args, **kwargs)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
content = {
"details": "Registered"
}
return Response(content,
status=status.HTTP_201_CREATED,
headers=headers)
def perform_create(self, serializer):
user = serializer.save(self.request)
complete_signup(self.request._request, user, None, None)
return user
class RegistrationAPIView(RegisterView, TokenMixin):
"""RegistrationAPIView"""
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
def create(self, request, *args, **kwargs):
"""rewrite method create"""
if User.objects.filter(username=request.data['username']).exists():
return Response(
{
'error': 'LOGIN',
'message': 'User was NOT created, because LOGIN is exists'
},
status=status.HTTP_409_CONFLICT)
if User.objects.filter(email=request.data['email']).exists():
return Response(
{
'error': 'EMAIL',
'message': 'User was NOT created, because EMAIL is exists',
},
status=status.HTTP_409_CONFLICT)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
# headers = self.get_success_headers(serializer.data)
email_confirm_token_send(user, self.get_token(user=user))
request.session.flush()
return Response(status=status.HTTP_201_CREATED)
def perform_create(self, serializer):
"""rewrite method perform_create"""
user = serializer.save(self.request)
# if user:
# try:
# payload = {}
# payload['id'] = user.id
# payload['exp'] = datetime.datetime.now() + datetime.timedelta(days=3)
# self.token = jwt.encode(payload, settings.SECRET_KEY, algorithm='HS256')
# except Exception as exp:
# raise exp
# complete_signup(self.request._request, user, None, None)
user = set_first_last_role(user, self.request)
return user
class RegisterUserProfileView(RegisterView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
user_status = request.data.get("status")
place_of_employment = request.data.get("place_of_employment")
about_yourself = request.data.get("about_yourself")
location = request.data.get("location")
if user_status:
user.status = user_status
if place_of_employment:
user.place_of_employment = place_of_employment
if about_yourself:
user.about_yourself = about_yourself
if location:
user.location = location
self.add_rating(user)
headers = self.get_success_headers(serializer.data)
return Response(self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers)
def mapping_for_rating(self, user, field):
rating_mapping = {
'status': user.status,
'place_of_employment': user.place_of_employment,
'about_yourself': user.about_yourself,
'location': user.location
}
if field:
return rating_mapping.get(field, None)
return None
def add_rating(self, user):
keys = user.__dict__.keys()
for key in keys:
res = self.mapping_for_rating(user, key)
if res:
user.rating += 1
user.save()
class Singup(CreateAPIView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
@sensitive_post_parameters_m
def dispatch(self, *args, **kwargs):
return super(Singup, self).dispatch(*args, **kwargs)
def get_response_data(self, user):
if allauth_settings.EMAIL_VERIFICATION == \
allauth_settings.EmailVerificationMethod.MANDATORY:
return {"detail": _("Verification e-mail sent.")}
if getattr(settings, 'REST_USE_JWT', False):
data = {'user': user, 'token': self.token}
return JWTSerializer(data).data
else:
return TokenSerializer(user.auth_token).data
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(self.get_response_data(user),
status=status.HTTP_200_OK,
headers=headers)
def perform_create(self, serializer):
user = serializer.save(self.request)
if getattr(settings, 'REST_USE_JWT', False):
self.token = jwt_encode(user)
else:
create_token(self.token_model, user, serializer)
current_site = get_current_site(self.request)
d = ({
'email': user.email,
'username': user.username,
'WEB_SITE_URL': WEB_SITE_URL
})
plaintext = get_template('email-template/email.txt')
htmly = get_template('email-template/welcome.html')
subject, from_email, to = "Welcome To Tajinder's English Classes", settings.DEFAULT_FROM_EMAIL, user.email
text_content = plaintext.render(d)
html_content = htmly.render(d)
# msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
# msg.attach_alternative(html_content, "text/html")
# msg.send()
return user
class RegistrationAPIView(RegisterView, TokenMixin):
"""RegistrationAPIView"""
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
def create(self, request, *args, **kwargs):
"""rewrite method create"""
if User.objects.filter(username=request.data['username']).exists():
return Response(
{
'error': 'LOGIN',
'message': 'User was NOT created, because LOGIN is exists'
},
status=status.HTTP_409_CONFLICT)
if User.objects.filter(email=request.data['email']).exists():
return Response(
{
'error': 'EMAIL',
'message': 'User was NOT created, because EMAIL is exists',
},
status=status.HTTP_409_CONFLICT)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
email_confirm_token_send(user, self.get_token(user=user))
log.info(msg='User {} was registered'.format(user.username))
request.session.flush()
return Response(status=status.HTTP_201_CREATED, headers=headers)
def perform_create(self, serializer):
"""rewrite method perform_create"""
user = serializer.save(self.request)
user = set_first_last_role(user, self.request)
return user
class RegisterView(CreateAPIView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
@sensitive_post_parameters_m
def dispatch(self, *args, **kwargs):
return super(RegisterView, self).dispatch(*args, **kwargs)
def get_response_data(self, user):
# if allauth_settings.EMAIL_VERIFICATION == \
# allauth_settings.EmailVerificationMethod.MANDATORY:
# return {"detail": _("Verification e-mail sent.")}
if getattr(settings, 'REST_USE_JWT', False):
data = {'user': user, 'token': self.token}
return JWTSerializer(data).data
else:
return TokenSerializer(user.auth_token).data
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers)
def perform_create(self, serializer):
user = serializer.save(self.request)
if getattr(settings, 'REST_USE_JWT', False):
self.token = jwt_encode(user)
else:
create_token(self.token_model, user, serializer)
# complete_signup(self.request._request, user,
# allauth_settings.EMAIL_VERIFICATION,
# None)
return user
class GoogleAuthorization(APIView):
authentication_classes = (CsrfExemptAuthentication, BasicAuthentication)
permission_classes = register_permission_classes()
def post(self, request):
token = request.POST.get('idtoken')
id_info = id_token.verify_oauth2_token(token, requests.Request())
user = authenticate(username=id_info.get('email'))
if not user:
google_user = GoogleRegistration(
data={
'first_name': id_info.get('given_name'),
'last_name': id_info.get('family_name'),
'email': id_info.get('email')
})
google_user.is_valid()
user = google_user.create(google_user.validated_data)
auth_login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return Response('Success', status=HTTP_200_OK)
class CustomRegisterView(RegisterView):
permission_classes = register_permission_classes()
authentication_classes = ()
class RegisterView(CreateAPIView):
from rest_auth.registration.app_settings import (
register_permission_classes, )
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
@sensitive_post_parameters_m
def dispatch(self, *args, **kwargs):
return super(RegisterView, self).dispatch(*args, **kwargs)
def get_response_data(self, user):
if (allauth_settings.EMAIL_VERIFICATION ==
allauth_settings.EmailVerificationMethod.MANDATORY):
return {"detail": _("Verification e-mail sent.")}
if getattr(settings, "REST_USE_JWT", False):
data = {"user": user, "token": self.token}
return JWTSerializer(data).data
else:
return TokenSerializer(user.auth_token).data
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
response = Response(
self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers,
)
if getattr(settings, "REST_USE_JWT", False):
from rest_framework_jwt.settings import (
api_settings as jwt_settings, )
if jwt_settings.JWT_AUTH_COOKIE:
from datetime import datetime
expiration = (datetime.utcnow() +
jwt_settings.JWT_EXPIRATION_DELTA)
response.set_cookie(
jwt_settings.JWT_AUTH_COOKIE,
self.token,
expires=expiration,
httponly=True,
)
return response
def perform_create(self, serializer):
user = serializer.save(self.request)
if getattr(settings, "REST_USE_JWT", False):
self.token = jwt_encode(user)
else:
create_token(self.token_model, user, serializer)
complete_signup(
self.request._request,
user,
allauth_settings.EMAIL_VERIFICATION,
None,
)
return user
def get_response_serializer(self):
if getattr(settings, "REST_USE_JWT", False):
response_serializer = JWTSerializer
else:
response_serializer = TokenSerializer
return response_serializer
class RegisterView(CreateAPIView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
@sensitive_post_parameters_m
def dispatch(self, *args, **kwargs):
return super(RegisterView, self).dispatch(*args, **kwargs)
def get_response_data(self, user):
if auth_settings.EMAIL_VERIFICATION == \
auth_settings.EmailVerificationMethod.MANDATORY:
return {"detail": _("Verification e-mail sent.")}
return TokenSerializer(user.auth_token).data
def create(self, request, *args, **kwargs):
try:
_user = User.objects.get(username=self.request.data['username']
, email=self.request.data['email'])
except:
_user = None
try:
verified = EmailAddress.objects.get(email=request.data['email']).verified
except:
verified = None
a=False
if _user and settings.ACCOUNT_LOGIN_BY_MAIL:
if auth_settings.EMAIL_VERIFICATION == \
auth_settings.EmailVerificationMethod.MANDATORY\
and not verified:
a = True
else:
user = _user
self.create_new_token(user)
headers = {}
else:
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
if a:
return Response("You need to confirm email",
status=status.HTTP_200_OK)
else:
return Response(self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers)
def perform_create(self, serializer):
user = serializer.save(self.request)
create_token(self.token_model, user, serializer)
complete_signup(self.request._request, user,
auth_settings.EMAIL_VERIFICATION,
None)
return user
def create_new_token(self,user):
try:
Token.objects.get(user=user).delete()
except:
pass
create_token(self.token_model, user , None)
class ApiRegistrationView(CreateAPIView):
serializer_class = RegisterSerializer
permission_classes = register_permission_classes()
token_model = TokenModel
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
try:
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
self.get_success_headers(serializer.data)
return HttpResponse(json.dumps({}),
content_type='application/json')
except ValidationError as e:
return create_validation_error_response(e)
def get_response_data(self, user):
return TokenSerializer(user.auth_token).data
def send_activation_email(self, user, serializer):
create_token(self.token_model, user, serializer)
token = account_activation_token.make_token(user)
params = {
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': token
}
confirmation_link = settings.FRONTEND_URL + "/#/confirm?" + urllib.parse.urlencode(
params)
context = {
'username': user.username,
'confirmation_link': confirmation_link,
'service_name': "DummyService"
}
message = Mail(from_email='*****@*****.**',
to_emails=user.email,
subject='Thank you for registration',
html_content=render_to_string(
"account/email/confirmation_mail.html", context))
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
print(response.status_code)
print(response.body)
print(response.headers)
except Exception as e:
print(e)
def perform_create(self, serializer):
if settings.BYPASS_ACCOUNT_REGISTRATION:
return None
user = serializer.save(self.request)
if settings.SEND_ACCOUNT_ACTIVATION_EMAIL:
self.send_activation_email(user, serializer)
else:
# Activate immediately
email_verify_obj = EmailAddress.objects.get(user=user)
email_verify_obj.verified = True
email_verify_obj.save()
return user
