def delete(self, request, **kwargs):
social_account = self.get_object(request, **kwargs)
if not self.has_object_permissions(request, social_account):
return Response(status=HTTP_404_NOT_FOUND)
try:
user_social_accounts = SocialAccount.objects.filter(
user=request.user)
get_adapter().validate_disconnect(social_account,
user_social_accounts)
except ValidationError as e:
return Response(e.message, status=HTTP_403_FORBIDDEN)
if social_account.provider == 'twitter':
identifier = 'https://twitter.com/{}'.format(
social_account.extra_data.get('screen_name', '').lower())
try:
uri = UserRecipientIdentifier.objects.get(
identifier=identifier)
uri.delete()
except UserRecipientIdentifier.DoesNotExist:
pass
social_account.delete()
return Response(status=HTTP_204_NO_CONTENT)
def _process_signup(request, sociallogin):
auto_signup = get_adapter(request).is_auto_signup_allowed(
request, sociallogin)
if not auto_signup:
request.session['socialaccount_sociallogin'] = sociallogin.serialize()
url = reverse('socialaccount_signup')
ret = HttpResponseRedirect(url)
else:
# Ok, auto signup it is, at least the e-mail address is ok.
# We still need to check the username though...
if account_settings.USER_MODEL_USERNAME_FIELD:
username = user_username(sociallogin.user)
try:
get_account_adapter(request).clean_username(username)
except ValidationError:
# This username is no good ...
user_username(sociallogin.user, '')
# FIXME: This part contains a lot of duplication of logic
# ("closed" rendering, create user, send email, in active
# etc..)
if not get_adapter(request).is_open_for_signup(request, sociallogin):
return render(
request,
"account/signup_closed." + account_settings.TEMPLATE_EXTENSION)
get_adapter(request).save_user(request, sociallogin, form=None)
ret = complete_social_signup(request, sociallogin)
return ret
def get(self, request, account_id):
"""
Handle the GET request of the view.
Disconnect the account.
Parameters
----------
request : django.http.HttpRequest
Object representing the request.
account_id : int
ID identifying the account in the database.
Returns
-------
django.http.HttpResponseRedirect
Redirecting to user profile page.
"""
account = None
try:
account = SocialAccount.objects.get(pk=account_id,
user=request.user)
except:
messages.error(request, 'The account could not be found.')
if account:
try:
get_adapter(request).validate_disconnect(
account,
SocialAccount.objects.filter(user=self.request.user))
account.delete()
messages.success(request, 'The account has been disconnected.')
except ValidationError, e:
messages.error(request, e)
def render_authentication_error(request,
provider_id,
error=AuthError.UNKNOWN,
exception=None,
extra_context=None):
try:
if extra_context is None:
extra_context = {}
get_adapter(request).authentication_error(request,
provider_id,
error=error,
exception=exception,
extra_context=extra_context)
except ImmediateHttpResponse as e:
return e.response
if error == AuthError.CANCELLED:
return HttpResponseRedirect(reverse('socialaccount_login_cancelled'))
context = {
'auth_error': {
'provider': provider_id,
'code': error,
'exception': exception
}
}
context.update(extra_context)
return render(
request, "socialaccount/authentication_error." +
account_settings.TEMPLATE_EXTENSION, context)
def clean(self):
cleaned_data = super(IntegrationForm, self).clean()
account = cleaned_data.get('account')
if account:
get_adapter(self.request).validate_disconnect(
account,
self.accounts)
return cleaned_data
def destroy(self, request, *args, **kwargs):
account = self.get_object()
try:
get_adapter().validate_disconnect(
account,
SocialAccount.objects.filter(user_id=account.user_id)
)
except ValidationError as e:
raise RestValidationError(str(e))
account.delete()
signals.social_account_removed.send(sender=SocialAccount,
request=self.request,
socialaccount=account)
return Response({'result': 'OK'})
def complete_login(self, request, app, token, **kwargs):
userob = kwargs["user"]
extra = kwargs["extra"]
extra_info = []
for item in extra:
item_serial = item.__dict__['display_name']
extra_info.append(item_serial)
#extra = serializers.serialize("json", extra)
logging.debug(extra_info)
#extra = json.dumps(extra)
# auth = ('bearer', token.token)
# resp = requests.get(self.profile_url,
# params={ 'oauth_token': token.token })
#extra_data = resp.json()
# uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user(name=userob.name,
username=userob.name,
email=userob.name)
account = SocialAccount(user=user,
uid=userob.id,
extra_data=extra_info,
provider=self.provider_id)
return SocialLogin(account)
def fb_complete_login(app, token):
print 'fb_complete_login'
min_friends = 0
try:
f = requests.get('https://graph.facebook.com/me/friends', params={'access_token': token.token})
friends = f.json()
if len(friends['data']) >= min_friends:
resp = requests.get('https://graph.facebook.com/me', params={'access_token': token.token})
extra_data = resp.json()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(email=extra_data.get('email'),
username=extra_data.get('username'),
first_name=extra_data.get('first_name'),
last_name=extra_data.get('last_name'))
account = SocialAccount(uid=uid,
provider=FacebookProvider.id,
extra_data=extra_data,
user=user)
return SocialLogin(account)
else:
from django.core.exceptions import PermissionDenied
raise PermissionDenied
except:
from django.core.exceptions import PermissionDenied
raise PermissionDenied
def sociallogin_from_response(self, request, response):
"""
Instantiates and populates a `SocialLogin` model based on the data
retrieved in `response`. The method does NOT save the model to the
DB.
Data for `SocialLogin` will be extracted from `response` with the
help of the `.extract_uid()`, `.extract_extra_data()`,
`.extract_common_fields()`, and `.extract_email_addresses()`
methods.
:param request: a Django `HttpRequest` object.
:param response: object retrieved via the callback response of the
social auth provider.
:return: A populated instance of the `SocialLogin` model (unsaved).
"""
# NOTE: Avoid loading models at top due to registry boot...
from allauth.socialaccount.models import SocialAccount, SocialLogin
adapter = get_adapter(request)
uid = self.extract_uid(response)
extra_data = self.extract_extra_data(response)
common_fields = self.extract_common_fields(response)
socialaccount = SocialAccount(extra_data=extra_data,
uid=uid,
provider=self.id)
email_addresses = self.extract_email_addresses(response)
self.cleanup_email_addresses(common_fields.get("email"),
email_addresses)
sociallogin = SocialLogin(account=socialaccount,
email_addresses=email_addresses)
user = sociallogin.user = adapter.new_user(request, sociallogin)
user.set_unusable_password()
adapter.populate_user(request, sociallogin, common_fields)
return sociallogin
def save(self, request):
adapter = get_adapter(request)
user = adapter.save_user(request,
self.sociallogin,
form=self,
commit=False)
join_channel = self.sociallogin.account.get_provider().name.upper()
user.join_channel = join_channel
user.login_id = str(user.join_channel) + '_id_' + str(user.id)
user.email = self.cleaned_data['email']
user.gender = self.cleaned_data['gender']
user.birth_year = self.cleaned_data['birth_year']
user.birth_month = self.cleaned_data['birth_month']
user.birth_day = self.cleaned_data['birth_day']
user.nickname = self.cleaned_data['nickname']
user.is_verified = True
name = self.sociallogin.account.extra_data.get('name', '')
if name:
user.name = name
else:
user.name = self.sociallogin.account.extra_data['properties'][
'nickname']
user.save()
self.custom_signup(request, user)
return user
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify',
{'assertion': assertion,
'audience': audience})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
email = resp.json()['email']
user = get_adapter() \
.populate_new_user(email=email)
extra_data = resp.json()
account = SocialAccount(uid=email,
provider=PersonaProvider.id,
extra_data=extra_data,
user=user)
# TBD: Persona e-mail addresses are verified, so we could check if
# a matching local user account already exists with an identical
# verified e-mail address and short-circuit the social login. Then
# again, this holds for all social providers that guarantee
# verified e-mail addresses, so if at all, short-circuiting should
# probably not be handled here...
login = SocialLogin(account)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def complete_login(self, request, app, token):
resp = requests.get(self.profile_url,
params={'access_token': token.token,
'alt': 'json'})
extra_data = resp.json()
# extra_data is something of the form:
#
# {u'family_name': u'Penners', u'name': u'Raymond Penners',
# u'picture': u'https://lh5.googleusercontent.com/-GOFYGBVOdBQ/AAAAAAAAAAI/AAAAAAAAAGM/WzRfPkv4xbo/photo.jpg',
# u'locale': u'nl', u'gender': u'male',
# u'email': u'*****@*****.**',
# u'link': u'https://plus.google.com/108204268033311374519',
# u'given_name': u'Raymond', u'id': u'108204268033311374519',
# u'verified_email': True}
#
# TODO: We could use verified_email to bypass allauth email verification
uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user(email=extra_data.get('email'),
last_name=extra_data.get('family_name'),
first_name=extra_data.get('given_name'))
email_addresses = []
if user.email and extra_data.get('verified_email'):
email_addresses.append(EmailAddress(email=user.email,
verified=True,
primary=True))
account = SocialAccount(extra_data=extra_data,
uid=uid,
provider=self.provider_id,
user=user)
return SocialLogin(account,
email_addresses=email_addresses)
def validate_unique_email(self, value):
try:
return super(SignupForm, self).validate_unique_email(value)
except forms.ValidationError:
raise forms.ValidationError(
get_adapter().error_messages['email_taken']
% self.sociallogin.account.get_provider().name)
def complete_login(self, request, app, token, **kwargs):
uid = kwargs.get("response", {}).get("uid")
resp = requests.get(self.profile_url, params={"access_token": token.token, "uid": uid})
extra_data = resp.json()
user = get_adapter().populate_new_user(username=extra_data.get("screen_name"), name=extra_data.get("name"))
account = SocialAccount(user=user, uid=uid, extra_data=extra_data, provider=self.provider_id)
return SocialLogin(account)
def sociallogin_from_response(self, request, response):
"""
COPIED FROM
https://github.com/pennersr/django-allauth/blob/5b1cbf485fa363ccb87513545e3b98f3c3bd81fa/allauth/socialaccount/providers/base.py#L52
TO PASS SocialApp TO EXTRACT METHODS PER
https://github.com/pennersr/django-allauth/issues/1297
"""
# NOTE: Avoid loading models at top due to registry boot...
from allauth.socialaccount.models import SocialLogin, SocialAccount
adapter = get_adapter()
app = self.get_app(request)
uid = self.extract_uid(response, app)
extra_data = self.extract_extra_data(response, app)
common_fields = self.extract_common_fields(response, app)
socialaccount = SocialAccount(extra_data=extra_data,
uid=uid,
provider=self.id)
email_addresses = self.extract_email_addresses(response, app)
self.cleanup_email_addresses(common_fields.get('email'),
email_addresses)
sociallogin = SocialLogin(account=socialaccount,
email_addresses=email_addresses)
user = sociallogin.user = adapter.new_user(request, sociallogin)
user.set_unusable_password()
adapter.populate_user(request, sociallogin, common_fields)
return sociallogin
def generate_client_secret(self):
"""Create a JWT signed with an apple provided private key"""
now = datetime.utcnow()
app = get_adapter().get_app(self.request, "apple")
if not app.key:
raise ImproperlyConfigured("Apple 'key' missing")
if not app.certificate:
raise ImproperlyConfigured("Apple 'certificate' missing")
claims = {
"iss": app.key,
"aud": "https://appleid.apple.com",
"sub": self.get_client_id(),
"iat": now,
"exp": now + timedelta(hours=1),
}
headers = {"kid": self.consumer_secret, "alg": "ES256"}
try:
client_secret = jwt.encode(payload=claims,
key=app.certificate,
algorithm="ES256",
headers=headers).decode("utf-8")
except AttributeError:
client_secret = jwt.encode(payload=claims,
key=app.certificate,
algorithm="ES256",
headers=headers)
return client_secret
def save(self, request):
adapter = get_adapter(request)
user = adapter.save_user(request, self.sociallogin, form=self)
user.get_newsletters = self.cleaned_data['get_newsletters']
user.save()
user.signup(user.username, user.email)
return user
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={ 'access_token': token.token,
'alt': 'json' })
extra_data = resp.json()
# extra_data is something of the form:
#
# {u'family_name': u'Penners', u'name': u'Raymond Penners',
# u'picture': u'https://lh5.googleusercontent.com/-GOFYGBVOdBQ/AAAAAAAAAAI/AAAAAAAAAGM/WzRfPkv4xbo/photo.jpg',
# u'locale': u'nl', u'gender': u'male',
# u'email': u'*****@*****.**',
# u'link': u'https://plus.google.com/108204268033311374519',
# u'given_name': u'Raymond', u'id': u'108204268033311374519',
# u'verified_email': True}
#
# TODO: We could use verified_email to bypass allauth email verification
uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user(email=extra_data.get('email'),
last_name=extra_data.get('family_name'),
first_name=extra_data.get('given_name'))
email_addresses = []
email = user_email(user)
if email and extra_data.get('verified_email'):
email_addresses.append(EmailAddress(email=email,
verified=True,
primary=True))
account = SocialAccount(extra_data=extra_data,
uid=uid,
provider=self.provider_id,
user=user)
return SocialLogin(account,
email_addresses=email_addresses)
def clean(self):
email = self.cleaned_data['email']
if email_address_exists(email):
raise forms.ValidationError(
get_adapter().error_messages['email_taken'] %
self.sociallogin.account.get_provider().name)
return super().clean()
def complete_login(self, request, app, token, **kwargs):
userob = kwargs["user"]
extra = kwargs["extra"]
extra_info = []
for item in extra:
item_serial = item.__dict__['display_name']
extra_info.append(item_serial)
#extra = serializers.serialize("json", extra)
logging.debug(extra_info)
#extra = json.dumps(extra)
# auth = ('bearer', token.token)
# resp = requests.get(self.profile_url,
# params={ 'oauth_token': token.token })
#extra_data = resp.json()
# uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user(name=userob.name,
username=userob.name,
email=userob.name)
account = SocialAccount(user=user,
uid=userob.id,
extra_data=extra_info,
provider=self.provider_id)
return SocialLogin(account)
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify', {
'assertion': assertion,
'audience': audience
})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
email = resp.json()['email']
user = get_adapter() \
.populate_new_user(email=email)
extra_data = resp.json()
account = SocialAccount(uid=email,
provider=PersonaProvider.id,
extra_data=extra_data,
user=user)
# TBD: Persona e-mail addresses are verified, so we could check if
# a matching local user account already exists with an identical
# verified e-mail address and short-circuit the social login. Then
# again, this holds for all social providers that guarantee
# verified e-mail addresses, so if at all, short-circuiting should
# probably not be handled here...
login = SocialLogin(account)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def delete(self, request, **kwargs):
social_account = self.get_object(request, **kwargs)
if not self.has_object_permissions(request, social_account):
return Response(status=HTTP_404_NOT_FOUND)
try:
user_social_accounts = SocialAccount.objects.filter(
user=request.user)
get_adapter().validate_disconnect(social_account,
user_social_accounts)
except ValidationError as e:
return Response(str(e), status=HTTP_403_FORBIDDEN)
social_account.delete()
return Response(status=HTTP_204_NO_CONTENT)
def complete_social_login(request, sociallogin):
assert not sociallogin.is_existing
sociallogin.lookup()
try:
get_adapter(request).pre_social_login(request, sociallogin)
signals.pre_social_login.send(sender=SocialLogin,
request=request,
sociallogin=sociallogin)
process = sociallogin.state.get('process')
if process == AuthProcess.REDIRECT:
return _social_login_redirect(request, sociallogin)
elif process == AuthProcess.CONNECT:
return _add_social_account(request, sociallogin)
else:
return _complete_social_login(request, sociallogin)
except ImmediateHttpResponse as e:
return e.response
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url, params={"oauth_token": token.token})
extra_data = resp.json()
uid = str(extra_data["_id"])
user = get_adapter().populate_new_user(
username=extra_data.get("display_name"), name=extra_data.get("name"), email=extra_data.get("email")
)
account = SocialAccount(user=user, uid=uid, extra_data=extra_data, provider=self.provider_id)
return SocialLogin(account)
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
initial = get_adapter().get_signup_form_initial_data(
self.sociallogin)
kwargs.update({
'initial': initial,
'email_required': kwargs.get('email_required',
app_settings.EMAIL_REQUIRED)})
super(SignupForm, self).__init__(*args, **kwargs)
def twitter_complete_login(extra_data):
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
account = SocialAccount(user=user,
uid=uid,
provider=TwitterProvider.id,
extra_data=extra_data)
return SocialLogin(account)
def twitter_complete_login(extra_data):
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
account = SocialAccount(user=user,
uid=uid,
provider=TwitterProvider.id,
extra_data=extra_data)
return SocialLogin(account)
def complete_login(self, request, app, token):
client = LinkedInAPI(request, app.client_id, app.secret, self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data["id"]
user = get_adapter().populate_new_user(
email=extra_data.get("email-address"),
first_name=extra_data.get("first-name"),
last_name=extra_data.get("last-name"),
)
account = SocialAccount(user=user, provider=self.provider_id, extra_data=extra_data, uid=uid)
return SocialLogin(account)
def ensure_staff_login_via_adfs(**kwargs):
adapter = get_adapter()
if isinstance(adapter, SocialAccountAdapter):
sociallogin = kwargs.get("sociallogin")
via_adfs = sociallogin and sociallogin.account.provider == ADFSOAuth2Provider.id
if not via_adfs:
changed, user = adapter.update_user_fields(kwargs["request"], user=kwargs["user"])
if changed:
user.save()
provider = registry.by_id(ADFSOAuth2Provider.id)
messages.warning(kwargs["request"], 'User account modified due to log in provider. Log in with the %s provider to restore functionality when needed.' % provider.name)
def test_is_auto_signup_allowed_override_for_helsinki_adfs(
settings, provider_id, expected):
settings.SOCIALACCOUNT_AUTO_SIGNUP = False
request = RequestFactory().get('/accounts/signup/')
account = SocialAccount(provider=provider_id)
sociallogin = SocialLogin(account=account)
assert get_adapter(request).is_auto_signup_allowed(request,
sociallogin) == expected
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
success_url = self.get_success_url()
try:
get_adapter(self.request).validate_disconnect(
self.object, SocialAccount.objects.filter(user=self.request.user)
)
except ValidationError:
messages.error(
self.request,
_(
"The third-party account could not be disconnected "
"because it is the only login method available."
),
)
else:
self.object.delete()
messages.success(
self.request, _("The third-party account has been successfully disconnected.")
)
return HttpResponseRedirect(success_url)
def save(self, request):
adapter = get_adapter(request)
user = adapter.save_user(request, self.sociallogin, form=self)
profile = Profile.objects.create(
user=user,
name=self.cleaned_data['name'],
nickname=self.cleaned_data['username'],
emailaddress=self.cleaned_data['email'],
)
return user
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={'access_token': token.token})
extra_data = resp.json()['data']
uid = str(extra_data['login'])
user = get_adapter().populate_new_user(
username=extra_data['login'], name=extra_data.get('full_name'))
account = SocialAccount(user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id)
return SocialLogin(account)
def complete_login(self, request, app, token):
client = TwitterAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
account = SocialAccount(user=user,
uid=uid,
provider=TwitterProvider.id,
extra_data=extra_data)
return SocialLogin(account)
def complete_login(self, request, app, token):
client = TwitterAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
account = SocialAccount(user=user,
uid=uid,
provider=TwitterProvider.id,
extra_data=extra_data)
return SocialLogin(account)
def complete_login(self, request, app, token):
client = VimeoAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(name=extra_data.get('display_name'),
username=extra_data.get('username'))
account = SocialAccount(user=user,
provider=self.provider_id,
extra_data=extra_data,
uid=uid)
return SocialLogin(account)
def get(self, request, account_id):
"""
Handle the GET request of the view.
Disconnect the account.
Parameters
----------
request : django.http.HttpRequest
Object representing the request.
account_id : int
ID identifying the account in the database.
Returns
-------
django.http.HttpResponseRedirect
Redirecting to user profile page.
"""
account = None
try:
account = SocialAccount.objects.get(
pk=account_id,
user=request.user)
except:
messages.error(request, 'The account could not be found.')
if account:
try:
get_adapter(request).validate_disconnect(
account,
SocialAccount.objects.filter(user=self.request.user))
account.delete()
messages.success(request, 'The account has been disconnected.')
except ValidationError as e:
messages.error(request, e)
return HttpResponseRedirect(reverse('admin:userprofile'))
def complete_login(self, request, app, token, **kwargs):
uid = kwargs.get('response', {}).get('uid')
resp = requests.get(self.profile_url,
params={ 'access_token': token.token,
'uid': uid })
extra_data = resp.json()
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
account = SocialAccount(user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id)
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={ 'oauth_token': token.token })
extra_data = resp.json()
uid = str(extra_data['_id'])
user = get_adapter() \
.populate_new_user(username=extra_data.get('display_name'),
name=extra_data.get('name'),
email=extra_data.get('email'))
account = SocialAccount(user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id)
return SocialLogin(account)
def callback(request):
client = _openid_consumer(request)
response = client.complete(dict(request.REQUEST.items()), request.build_absolute_uri(request.path))
if response.status == consumer.SUCCESS:
account = SocialAccount(uid=response.identity_url, provider=OpenIDProvider.id, extra_data={})
account.user = get_adapter().populate_new_user(request, account, email=_get_email_from_response(response))
login = SocialLogin(account)
login.state = SocialLogin.unstash_state(request)
ret = complete_social_login(request, login)
elif response.status == consumer.CANCEL:
ret = HttpResponseRedirect(reverse("socialaccount_login_cancelled"))
else:
ret = render_authentication_error(request)
return ret
def complete_login(self, request, app, token):
client = VimeoAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
account = SocialAccount(provider=self.provider_id,
extra_data=extra_data,
uid=uid)
account.user = get_adapter() \
.populate_new_user(request,
account,
name=extra_data.get('display_name'),
username=extra_data.get('username'))
return SocialLogin(account)
def wykop_complete_login(app, connectData):
import wykop
client = wykop.WykopAPI(app.client_id, app.secret)
extra_data = client.get_profile(connectData['login'])
user = get_adapter() \
.populate_new_user(email=extra_data.get('email').split(":")[0] + '@wykop.pl',
username=extra_data.get('login'),
name=extra_data.get('name'))
account = SocialAccount(uid=extra_data['login'],
provider=WykopProvider.id,
extra_data=extra_data,
user=user)
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
headers={'Authorization': 'Bearer ' + token.token})
extra_data = resp.json()
uid = str(extra_data['uid'])
user = get_adapter() \
.populate_new_user(email=extra_data.get('email'),
last_name=extra_data.get('last_name'),
first_name=extra_data.get('first_name'))
account = SocialAccount(user=user,
uid=uid,
provider=self.provider_id,
extra_data=extra_data)
return SocialLogin(account)
def save(self, request):
adapter = get_adapter(request)
user = adapter.save_user(request,
self.sociallogin,
form=self,
commit=False)
user.phone_number = self.cleaned_data['phone_number']
user.nickname = self.cleaned_data['nickname']
user.is_agreed_1 = True
user.is_agreed_2 = True
user.save()
self.custom_signup(request, user)
return user
def complete_login(self, request, app, token):
client = LinkedInAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(email=extra_data.get('email-address'),
first_name=extra_data.get('first-name'),
last_name=extra_data.get('last-name'))
account = SocialAccount(user=user,
provider=self.provider_id,
extra_data=extra_data,
uid=uid)
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={ 'oauth_token': token.token })
extra_data = resp.json()
uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user(name=extra_data.get('full_name'),
username=extra_data.get('username'),
email=extra_data.get('email'))
account = SocialAccount(user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id)
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
print "login token", token, "|", token.token, "|", token.token_secret
print "request code", request.POST
resp = requests.get(self.profile_url,
params={ 'access_token': token.token })
# print resp
# extra_data = resp.json()
# print extra_data
# uid = str(extra_data['id'])
user = get_adapter() \
.populate_new_user()
account = SocialAccount(user=user,
provider=self.provider_id)
print "account", account
return SocialLogin(account)
def complete_login(self, request, app, token):
client = DropboxAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['uid']
account = SocialAccount(uid=uid,
provider=DropboxProvider.id,
extra_data=extra_data)
account.user = get_adapter() \
.populate_new_user(request,
account,
username=extra_data.get('display_name'),
name=extra_data.get('display_name'),
email=extra_data.get('email'))
return SocialLogin(account)
def fb_complete_login(app, token):
resp = requests.get('https://graph.facebook.com/me',
params={ 'access_token': token.token })
extra_data = resp.json()
uid = extra_data['id']
user = get_adapter() \
.populate_new_user(email=extra_data.get('email'),
username=extra_data.get('username'),
first_name=extra_data.get('first_name'),
last_name=extra_data.get('last_name'))
account = SocialAccount(uid=uid,
provider=FacebookProvider.id,
extra_data=extra_data,
user=user)
return SocialLogin(account)
def complete_login(self, request, app, token):
client = LinkedInAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
account = SocialAccount(provider=self.provider_id,
extra_data=extra_data,
uid=uid)
account.user = get_adapter() \
.populate_new_user(request,
account,
email=extra_data.get('email-address'),
first_name=extra_data.get('first-name'),
last_name=extra_data.get('last-name'))
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
uid = kwargs['response']['user_id']
resp = requests.get(self.profile_url,
params={'access_token': token.token,
'fields': ','.join(USER_FIELDS),
'user_ids': uid})
resp.raise_for_status()
extra_data = resp.json()['response'][0]
account = SocialAccount(extra_data=extra_data,
uid=str(uid),
provider=self.provider_id)
account.user = get_adapter() \
.populate_new_user(request,
account,
last_name=extra_data.get('family_name'),
username=extra_data.get('screen_name'),
first_name=extra_data.get('given_name'))
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(
self.profile_url,
params={ 'access_token': token.token }
)
extra_data = resp.json()['data']
uid = str(extra_data['login'])
user = get_adapter().populate_new_user(
username=extra_data['login'],
name=extra_data.get('full_name')
)
account = SocialAccount(
user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id
)
return SocialLogin(account)
def login(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = LoginForm(request.REQUEST)
if form.is_valid():
email = form.cleaned_data['email']
password = form.cleaned_data['password']
try:
userr = User.objects.get(email=email)
userauth = authenticate(email=email, password=password)
if userauth is not None : #caso login valido
authlogin(request, userauth)
return HttpResponseRedirect('/')
else: #login nao valido
msg = gettext("The login and/or password you specified are not correct.")
context = {'form': form, 'erros': msg}
return render_to_response('account/signup_univ.html', context, context_instance=RequestContext(request))
except User.DoesNotExist: # email ainda nao existe, cria
user = get_adapter().populate_new_user(email=email)
user.has_usable_password()
user.set_password(password)
account = SocialAccount(uid=email,
provider=UniversityProvider.id,
user=user,
extra_data='{"university":"%s"}' % email.split('@')[1])
login = SocialLogin(account)
#login.state = SocialLogin.unmarshall_state(request.REQUEST.get('state'))
u = login.account.user
u.has_usable_password()
u.set_password(password)
login.account.user = u
ret = complete_social_login(request, login)
return ret
else:
context = {'form': form}
return render_to_response('account/signup_univ.html',context, context_instance=RequestContext(request))
else:
form = LoginForm()
context = {'form': form}
return render_to_response('account/signup_univ.html',context, context_instance=RequestContext(request))
def complete_login(self, request, app, token):
provider = registry.by_id(app.provider)
site = provider.get_site()
resp = requests.get(self.profile_url,
params={ 'access_token': token.token,
'key': app.key,
'site': site })
extra_data = resp.json()['items'][0]
# `user_id` varies if you use the same account for
# e.g. StackOverflow and ServerFault. Therefore, we pick
# `account_id`.
uid = str(extra_data['account_id'])
user = get_adapter() \
.populate_new_user(username=extra_data.get('display_name'))
account = SocialAccount(user=user,
uid=uid,
extra_data=extra_data,
provider=self.provider_id)
return SocialLogin(account)
def complete_login(self, request, app, token, **kwargs):
uid = kwargs['response']['user_id']
resp = requests.get(self.profile_url,
params={'access_token': token.token,
'fields': ','.join(USER_FIELDS),
'user_ids': uid})
resp.raise_for_status()
extra_data = resp.json()['response'][0]
# extra_data is something of the form:
# {u'response': [{u'last_name': u'Penners', u'university_name': u'', u'photo': u'http://vk.com/images/camera_c.gif', u'sex': 2, u'photo_medium': u'http://vk.com/images/camera_b.gif', u'relation': u'0', u'timezone': 1, u'photo_big': u'http://vk.com/images/camera_a.gif', u'uid': 219004864, u'universities': [], u'city': u'1430', u'first_name': u'Raymond', u'faculty_name': u'', u'online': 1, u'counters': {u'videos': 0, u'online_friends': 0, u'notes': 0, u'audios': 0, u'photos': 0, u'followers': 0, u'groups': 0, u'user_videos': 0, u'albums': 0, u'friends': 0}, u'home_phone': u'', u'faculty': 0, u'nickname': u'', u'screen_name': u'id219004864', u'has_mobile': 1, u'country': u'139', u'university': 0, u'graduation': 0, u'activity': u'', u'last_seen': {u'time': 1377805189}}]}
user = get_adapter() \
.populate_new_user(last_name=extra_data.get('family_name'),
username=extra_data.get('screen_name'),
first_name=extra_data.get('given_name'))
account = SocialAccount(extra_data=extra_data,
uid=str(uid),
provider=self.provider_id,
user=user)
return SocialLogin(account)
def complete_login(self, request, app, token, email_addresses=[]):
client = TwitterAPI(request, app.client_id, app.secret,
self.request_token_url)
extra_data = client.get_user_info()
uid = extra_data['id']
user = User.objects.filter(username=extra_data.get('screen_name'))
if user:
return user
else:
user = get_adapter() \
.populate_new_user(username=extra_data.get('screen_name'),
name=extra_data.get('name'))
user.save()
account = SocialAccount(user=user,
uid=uid,
provider=TwitterProvider.id,
extra_data=extra_data)
account.save()
application = SocialApp.objects.get(secret=app.secret)
sample_token = SocialToken.objects.filter(app=application, account=account)
if sample_token:
token = sample_token[0]
else:
token = SocialToken(app=application,
account=account,
token=request.session["oauth_api.twitter.com_access_token"]["oauth_token"],
token_secret=request.session["oauth_api.twitter.com_access_token"][
"oauth_token_secret"])
token.save()
mail = send_email_confirmation(request=request, user=user, signup=True)
return SocialLogin(account=account, token=token, email_addresses=email_addresses)
def save(self, request):
adapter = get_adapter()
user = adapter.save_user(request, self.sociallogin, form=self)
return user
def is_open(self):
return get_adapter().is_open_for_signup(self.request, self.sociallogin)
