django-rest-auth/rest_auth/registration/serializers.py

218 lines
7.8 KiB
Python
Raw Normal View History

from django.http import HttpRequest
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth import get_user_model
2015-11-24 13:11:46 +03:00
try:
from allauth.account import app_settings as allauth_settings
from allauth.utils import (email_address_exists,
get_username_max_length)
from allauth.account.adapter import get_adapter
from allauth.account.utils import setup_user_email
from allauth.socialaccount.helpers import complete_social_login
from allauth.socialaccount.models import SocialAccount
from allauth.socialaccount.providers.base import AuthProcess
2015-11-24 13:11:46 +03:00
except ImportError:
2016-12-22 01:08:56 +03:00
raise ImportError("allauth needs to be added to INSTALLED_APPS.")
2015-11-24 13:11:46 +03:00
from rest_framework import serializers
from requests.exceptions import HTTPError
2015-11-26 12:38:25 +03:00
class SocialAccountSerializer(serializers.ModelSerializer):
"""
serialize allauth SocialAccounts for use with a REST API
"""
class Meta:
model = SocialAccount
fields = (
'id',
'provider',
'uid',
'last_login',
'date_joined',
)
class SocialLoginSerializer(serializers.Serializer):
2015-08-17 13:34:59 +03:00
access_token = serializers.CharField(required=False, allow_blank=True)
code = serializers.CharField(required=False, allow_blank=True)
def _get_request(self):
request = self.context.get('request')
if not isinstance(request, HttpRequest):
request = request._request
return request
2015-07-23 22:33:48 +03:00
def get_social_login(self, adapter, app, token, response):
"""
2016-12-22 01:08:56 +03:00
:param adapter: allauth.socialaccount Adapter subclass.
Usually OAuthAdapter or Auth2Adapter
:param app: `allauth.socialaccount.SocialApp` instance
:param token: `allauth.socialaccount.SocialToken` instance
:param response: Provider's response for OAuth1. Not used in the
2016-12-22 01:08:56 +03:00
:returns: A populated instance of the
`allauth.socialaccount.SocialLoginView` instance
"""
request = self._get_request()
social_login = adapter.complete_login(request, app, token, response=response)
social_login.token = token
return social_login
def validate(self, attrs):
view = self.context.get('view')
request = self._get_request()
if not view:
2015-04-28 11:22:08 +03:00
raise serializers.ValidationError(
2016-12-22 01:08:56 +03:00
_("View is not defined, pass it as a context variable")
2015-04-28 11:22:08 +03:00
)
adapter_class = getattr(view, 'adapter_class', None)
if not adapter_class:
2016-12-22 01:08:56 +03:00
raise serializers.ValidationError(_("Define adapter_class in view"))
adapter = adapter_class(request)
app = adapter.get_provider().get_app(request)
# More info on code vs access_token
# http://stackoverflow.com/questions/8666316/facebook-oauth-2-0-code-and-token
# Case 1: We received the access_token
if attrs.get('access_token'):
access_token = attrs.get('access_token')
# Case 2: We received the authorization code
elif attrs.get('code'):
self.callback_url = getattr(view, 'callback_url', None)
self.client_class = getattr(view, 'client_class', None)
if not self.callback_url:
raise serializers.ValidationError(
2016-12-22 01:08:56 +03:00
_("Define callback_url in view")
)
if not self.client_class:
raise serializers.ValidationError(
2016-12-22 01:08:56 +03:00
_("Define client_class in view")
)
code = attrs.get('code')
2015-08-10 11:24:21 +03:00
provider = adapter.get_provider()
scope = provider.get_scope(request)
client = self.client_class(
request,
app.client_id,
app.secret,
2015-08-10 11:24:21 +03:00
adapter.access_token_method,
adapter.access_token_url,
self.callback_url,
scope
)
token = client.get_access_token(code)
access_token = token['access_token']
2015-08-14 14:49:47 +03:00
2015-08-13 10:56:25 +03:00
else:
2016-12-22 01:08:56 +03:00
raise serializers.ValidationError(
_("Incorrect input. access_token or code is required."))
social_token = adapter.parse_token({'access_token': access_token})
social_token.app = app
try:
login = self.get_social_login(adapter, app, social_token, access_token)
complete_social_login(request, login)
except HTTPError:
raise serializers.ValidationError(_("Incorrect value"))
if not login.is_existing:
# We have an account already signed up in a different flow
# with the same email address: raise an exception.
# This needs to be handled in the frontend. We can not just
# link up the accounts due to security constraints
2017-11-12 12:32:27 +03:00
if allauth_settings.UNIQUE_EMAIL:
# Do we have an account already with this email address?
2017-11-12 12:32:27 +03:00
account_exists = get_user_model().objects.filter(
email=login.user.email,
2017-11-12 12:32:27 +03:00
).exists()
if account_exists:
raise serializers.ValidationError(
2017-11-12 12:32:27 +03:00
_("User is already registered with this e-mail address.")
)
login.lookup()
login.save(request, connect=True)
2017-11-12 12:32:27 +03:00
2015-01-09 14:05:14 +03:00
attrs['user'] = login.account.user
return attrs
2015-11-24 13:11:46 +03:00
class SocialConnectMixin(object):
def get_social_login(self, *args, **kwargs):
"""
Set the social login process state to connect rather than login
Refer to the implementation of get_social_login in base class and to the
allauth.socialaccount.helpers module complete_social_login function.
"""
social_login = super(SocialConnectMixin, self).get_social_login(*args, **kwargs)
social_login.state['process'] = AuthProcess.CONNECT
return social_login
class SocialConnectSerializer(SocialConnectMixin, SocialLoginSerializer):
pass
2015-11-24 13:11:46 +03:00
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
2015-11-24 13:11:46 +03:00
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
2015-11-24 13:11:46 +03:00
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address."))
2015-11-24 13:11:46 +03:00
return email
def validate_password1(self, password):
2015-11-24 13:11:46 +03:00
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(_("The two password fields didn't match."))
return data
2015-11-24 13:11:46 +03:00
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', '')
}
2015-11-24 13:11:46 +03:00
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
self.cleaned_data = self.get_cleaned_data()
2015-11-24 13:11:46 +03:00
adapter.save_user(request, user, self)
self.custom_signup(request, user)
setup_user_email(request, user, [])
return user
class VerifyEmailSerializer(serializers.Serializer):
key = serializers.CharField()