def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
self.complete_url = "/complete/{0}/".format(self.backend.name)
self.strategy = TestStrategy(self.backend, TestStorage, redirect_uri=self.complete_url)
self.strategy.set_settings(
{"SOCIAL_AUTH_AUTHENTICATION_BACKENDS": (self.backend_path, "tests.backends.broken_test.BrokenBackendAuth")}
)
# Force backends loading to trash PSA cache
load_backends(self.strategy.get_setting("SOCIAL_AUTH_AUTHENTICATION_BACKENDS"), force_load=True)
def test_load_backends(self):
loaded_backends = load_backends((
'social.backends.github.GithubOAuth2',
'social.backends.facebook.FacebookOAuth2',
'social.backends.flickr.FlickrOAuth'
), force_load=True)
keys = list(loaded_backends.keys())
keys.sort()
self.assertEqual(keys, ['facebook', 'flickr', 'github'])
backends = ()
loaded_backends = load_backends(backends, force_load=True)
self.assertEqual(len(list(loaded_backends.keys())), 0)
def test_load_backends(self):
loaded_backends = load_backends((
'social.backends.github.GithubOAuth2',
'social.backends.facebook.FacebookOAuth2',
'social.backends.flickr.FlickrOAuth'
))
keys = list(loaded_backends.keys())
keys.sort()
expect(keys).to.equal(['facebook', 'flickr', 'github'])
backends = ()
loaded_backends = load_backends(backends, force_load=True)
expect(len(list(loaded_backends.keys()))).to.equal(0)
def test_load_backends(self):
loaded_backends = load_backends(
('social.backends.github.GithubOAuth2',
'social.backends.facebook.FacebookOAuth2',
'social.backends.flickr.FlickrOAuth'),
force_load=True)
keys = list(loaded_backends.keys())
keys.sort()
expect(keys).to.equal(['facebook', 'flickr', 'github'])
backends = ()
loaded_backends = load_backends(backends, force_load=True)
expect(len(list(loaded_backends.keys()))).to.equal(0)
def test_load_backends(self):
loaded_backends = load_backends(
('social.backends.github.GithubOAuth2',
'social.backends.facebook.FacebookOAuth2',
'social.backends.flickr.FlickrOAuth'),
force_load=True)
keys = list(loaded_backends.keys())
keys.sort()
self.assertEqual(keys, ['facebook', 'flickr', 'github'])
backends = ()
loaded_backends = load_backends(backends, force_load=True)
self.assertEqual(len(list(loaded_backends.keys())), 0)
def setUp(self):
HTTPretty.enable()
Backend = module_member(self.backend_path)
self.strategy = TestStrategy(TestStorage)
self.complete_url = self.raw_complete_url.format(Backend.name)
self.backend = Backend(self.strategy, redirect_uri=self.complete_url)
self.strategy.set_settings({
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS':
(self.backend_path,
'social.tests.backends.test_broken.BrokenBackendAuth')
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True)
def register(request):
"""
Registration form.
"""
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, "email")
else:
form = form_class()
backends = set(load_backends(BACKENDS).keys())
return render(
request,
"accounts/register.html",
{
"registration_email": "email" in backends,
"registration_backends": backends - set(["email"]),
"title": _("User registration"),
"form": form,
},
)
def register(request):
'''
Registration form.
'''
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, 'email')
else:
form = form_class()
backends = set(load_backends(BACKENDS).keys())
return render(
request,
'accounts/register.html',
{
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
}
)
def view_profile(request, user_id, **kwargs):
query_set = User.objects.filter(id=user_id)
if not query_set.exists():
return view_profile(request, request.user.id, error_messages=['User with user_id='+str(user_id)+' could not be found.'])
user = query_set[0]
profile = None
query_set = UserProfile.objects.filter(user=user)
if not query_set.exists():
profile = UserProfile()
profile.user = user
profile.save()
else:
profile = query_set[0]
context_dict = {}
if int(user_id) == int(request.user.id):
context_dict = {
'user_form': EditUserForm(initial=model_to_dict(user)),
'profile_form': UserProfileForm(initial=model_to_dict(profile)),
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'editing': 'editing' in kwargs and kwargs['editing'] == 'editing',
}
context_dict['disp_user'] = user
context_dict['disp_user_is_sm'] = (user.is_superuser) or (Permission.objects.get(codename='site_manager') in user.user_permissions.all()) #user.has_perm('users.site_manager')
if 'error_messages' in kwargs:
context_dict['error_messages'] = kwargs['error_messages']
return render(request, 'profile.html', context_dict)
def weblate_login(request):
'''
Login handler, just wrapper around login.
'''
# Redirect logged in users to profile
if request.user.is_authenticated():
return redirect_profile()
# Redirect if there is only one backend
auth_backends = list(load_backends(BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != 'email':
return redirect('social:begin', auth_backends[0])
return auth_views.login(request,
template_name='accounts/login.html',
authentication_form=LoginForm,
extra_context={
'login_backends':
[x for x in auth_backends if x != 'email'],
'can_reset':
'email' in auth_backends,
'title':
_('Login'),
})
def get_context_data(self, **kwargs):
context = super(RequireEmail, self).get_context_data(**kwargs)
context['email_required'] = True
context['backend'] = self.session['partial_pipeline']['backend']
context['available_backends'] = \
load_backends(settings.AUTHENTICATION_BACKENDS)
return context
def register(request):
'''
Registration form.
'''
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, 'email')
else:
form = form_class()
backends = load_backends(BACKENDS).keys()
# Redirect if there is only one backend
if len(backends) == 1 and backends[0] != 'email':
return redirect('social:begin', backends[0])
backends = set(backends)
return render(
request,
'accounts/register.html',
{
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
}
)
def index(request, template_name='index.html'):
user = request.user
print "User : "******"provider : ", provider
social = user.social_auth.get(provider=provider)
print "social.extra_data : ", social.extra_data
access_token = social.extra_data['access_token']
print "access_token", access_token
# print "social_auth : ", user.social_auth
# print "social_auth.values_list('provider') : ", user.social_auth.values_list('provider')
# print "social_auth.values_list('extra_data') : ", user.social_auth.values_list('extra_data')
# print "social_auth.provider : ", user.social_auth.provider
# social = user.social_auth.get(provider='google')
# print "social : ", social
# print "social.extra_data['access_token'] : ", social.extra_data['access_token']
context = {
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'access_token': access_token,
}
return render(request, template_name, context)
def context(**extra):
"""
Adding default context to rendered page.
"""
return dict({
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
}, **extra)
def get_active_auth_strategies(settings):
"""Give the list of available social auth providers.
Includes multiple instances if a provider can have multiple servers.
This currently includes SAML, and eventually wordpress.
TODO: Should replace the login_providers config variable"""
all_backends = load_backends(
settings.get('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'))
for backend_name in all_backends:
def get_setting(name):
return (settings.get(
setting_name(SETTING_PREFIX, backend_name, name), None)
or settings.get(setting_name(backend_name, name), None))
if backend_name == 'wordpress-oauth2':
# TODO: This special case needs to be treated the same as saml asap.
# Also: maybe check preferences
yield backend_name
elif backend_name == 'saml':
# special case: Multiple IDPs
idps = get_setting('ENABLED_IDPS') or {}
for idp in idps.keys():
yield 'saml:' + idp
elif get_setting('key'):
yield backend_name
def register(request):
"""
Registration form.
"""
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, "email")
else:
form = form_class()
backends = load_backends(BACKENDS).keys()
# Redirect if there is only one backend
if len(backends) == 1 and backends[0] != "email":
return redirect("social:begin", backends[0])
backends = set(backends)
return render(
request,
"accounts/register.html",
{
"registration_email": "email" in backends,
"registration_backends": backends - set(["email"]),
"title": _("User registration"),
"form": form,
},
)
def weblate_login(request):
'''
Login handler, just wrapper around login.
'''
# Redirect logged in users to profile
if request.user.is_authenticated():
return redirect('profile')
# Redirect if there is only one backend
auth_backends = list(load_backends(BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != 'email':
return redirect('social:begin', auth_backends[0])
return auth_views.login(
request,
template_name='accounts/login.html',
authentication_form=LoginForm,
extra_context={
'login_backends': [
x for x in auth_backends if x != 'email'
],
'can_reset': 'email' in auth_backends,
'title': _('Login'),
}
)
def register(request):
'''
Registration form.
'''
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, 'email')
else:
form = form_class()
backends = load_backends(BACKENDS).keys()
# Redirect if there is only one backend
if len(backends) == 1 and backends[0] != 'email':
return redirect('social:begin', backends[0])
backends = set(backends)
return render(
request, 'accounts/register.html', {
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
})
def register(request):
"""
Registration form.
"""
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
return complete(request, "email")
else:
form = form_class()
return render_to_response(
"accounts/register.html",
RequestContext(
request,
{
"registration_backends": [x for x in load_backends(BACKENDS).keys() if x != "email"],
"title": _("User registration"),
"form": form,
},
),
)
def register(request):
'''
Registration form.
'''
if appsettings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid() and appsettings.REGISTRATION_OPEN:
# Ensure we do registration in separate session
# not sent to client
request.session.create()
result = complete(request, 'email')
request.session.save()
request.session = None
return result
else:
form = form_class()
backends = set(load_backends(BACKENDS).keys())
# Redirect if there is only one backend
if len(backends) == 1 and 'email' not in backends:
return redirect('social:begin', backends.pop())
return render(
request, 'accounts/register.html', {
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
})
def reset_password(request):
'''
Password reset handling.
'''
if 'email' not in load_backends(BACKENDS).keys():
messages.error(
request,
_('Can not reset password, email authentication is disabled!')
)
return redirect('login')
if request.method == 'POST':
form = ResetForm(request.POST)
if form.is_valid():
user = form.cleaned_data['email']
user.set_unusable_password()
user.save()
if not request.session.session_key:
request.session.create()
request.session['password_reset'] = True
return complete(request, 'email')
else:
form = ResetForm()
return render(
request,
'accounts/reset.html',
{
'title': _('Password reset'),
'form': form,
}
)
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
self.strategy = TestStrategy(self.backend, TestStorage)
self.name = self.backend.name.upper().replace("-", "_")
self.complete_url = self.strategy.build_absolute_uri(self.raw_complete_url.format(self.backend.name))
backends = (self.backend_path, "social.tests.backends.test_broken.BrokenBackendAuth")
self.strategy.set_settings({"SOCIAL_AUTH_AUTHENTICATION_BACKENDS": backends})
self.strategy.set_settings(self.extra_settings())
# Force backends loading to trash PSA cache
load_backends(backends, force_load=True)
User.reset_cache()
TestUserSocialAuth.reset_cache()
TestNonce.reset_cache()
TestAssociation.reset_cache()
TestCode.reset_cache()
def reset_password(request):
'''
Password reset handling.
'''
if 'email' not in load_backends(BACKENDS).keys():
messages.error(
request,
_('Can not reset password, email authentication is disabled!'))
return redirect('login')
if request.method == 'POST':
form = ResetForm(request.POST)
if form.is_valid():
# Force creating new session
request.session.create()
if request.user.is_authenticated():
logout(request)
request.session['password_reset'] = True
return complete(request, 'email')
else:
form = ResetForm()
return render(request, 'accounts/reset.html', {
'title': _('Password reset'),
'form': form,
})
def reset_password(request):
"""
Password reset handling.
"""
if "email" not in load_backends(BACKENDS).keys():
messages.error(request, _("Can not reset password, email authentication is disabled!"))
return redirect("login")
if request.method == "POST":
form = ResetForm(request.POST)
if form.is_valid():
user = form.cleaned_data["email"]
user.set_unusable_password()
user.save()
# Force creating new session
request.session.create()
if request.user.is_authenticated():
logout(request)
request.session["password_reset"] = True
return complete(request, "email")
else:
form = ResetForm()
return render(request, "accounts/reset.html", {"title": _("Password reset"), "form": form})
def user_profile(request):
profile = request.user.get_profile()
if request.method == "POST":
# Read params
form = ProfileForm(request.POST, instance=profile)
subscriptionform = SubscriptionForm(request.POST, instance=profile)
userform = UserForm(request.POST, instance=request.user)
if appsettings.DEMO_SERVER and request.user.username == "demo":
messages.warning(request, _("You can not change demo profile on the demo server."))
return redirect("profile")
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = redirect("profile")
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _("Your profile has been updated."))
return response
else:
form = ProfileForm(instance=profile)
subscriptionform = SubscriptionForm(instance=profile)
userform = UserForm(instance=request.user)
social = request.user.social_auth.all()
social_names = [assoc.provider for assoc in social]
new_backends = [x for x in load_backends(BACKENDS).keys() if x == "email" or x not in social_names]
response = render_to_response(
"accounts/profile.html",
RequestContext(
request,
{
"form": form,
"userform": userform,
"subscriptionform": subscriptionform,
"profile": profile,
"title": _("User profile"),
"licenses": Project.objects.exclude(license=""),
"associated": social,
"new_backends": new_backends,
},
),
)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language)
return response
def loginpage(request):
"""
If a user wants to login, he opens the url named `cas-login`, which renders the cas_loginpage.html.
"""
logging.info("Start login for accessing a base")
if request.method == "GET":
service = request.GET['service']
m = re.match(r".*/userland/(?P<username>.*?)/(?P<basename>.*?)/",
service)
if m:
# we received an URI
username = m.group('username')
basename = m.group('basename')
Base.objects.get(name=basename, user__username=username)
request.session['next'] = service
else:
# we received an host, project is proxed
host = urlparse(service).netloc
base = Base.objects.get(frontend_host=host)
username = base.user.username
basename = base.name
request.session['next'] = "https://%s" % host
if request.user.is_authenticated:
user = request.user
logger.info("Next: " + request.session['next'])
return render(
request, 'aaa/cas_loginpage.html', {
'user':
user,
'userland':
username,
'basename':
basename,
'available_backends':
load_backends(settings.AUTHENTICATION_BACKENDS)
})
elif request.method == "POST":
username = request.POST['username']
password = request.POST['password']
service = request.POST['service']
user = authenticate(username=username,
password=password,
redirect_uri="/cas/login/")
if user is not None:
if user.is_active:
auth_login(request, user)
ticket = Ticket.objects.create_ticket(user=user)
return redirect(service + "?ticket=%s" % ticket.ticket)
else:
return redirect('/disabled')
else:
# Return an 'invalid login' error message.
#...
return redirect('/')
def setUp(self):
HTTPretty.enable()
Backend = module_member(self.backend_path)
self.strategy = TestStrategy(TestStorage)
self.complete_url = self.raw_complete_url.format(Backend.name)
self.backend = Backend(self.strategy, redirect_uri=self.complete_url)
self.strategy.set_settings({
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
self.backend_path,
'social.tests.backends.test_broken.BrokenBackendAuth'
)
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True
)
def signin(req):
from astrometry.net import settings
from social.backends.utils import load_backends
ctxt = RequestContext(req)
ctxt.update({
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS)
})
return render_to_response('signin.html', ctxt)
def setUp(self):
HTTPretty.enable()
Backend = module_member(self.backend_path)
self.strategy = views.load_strategy()
self.backend = Backend(self.strategy, redirect_uri=self.complete_url)
self.name = self.backend.name.upper().replace('-', '_')
self.complete_url = self.strategy.build_absolute_uri(
self.raw_complete_url.format(self.backend.name))
backends = (self.backend_path, )
load_backends(backends, force_load=True)
user_data_body = json.loads(self.user_data_body)
self.email = '*****@*****.**'
user_data_body['email'] = self.email
self.user_data_body = json.dumps(user_data_body)
self.do_rest_login()
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
self.complete_url = '/complete/{0}/'.format(self.backend.name)
self.strategy = TestStrategy(self.backend, TestStorage,
redirect_uri=self.complete_url)
self.strategy.set_settings({
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
self.backend_path,
'tests.backends.broken_test.BrokenBackendAuth'
)
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True
)
def context(**extra):
return dict(
{
'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope': ' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS)
}, **extra)
def context(**extra):
return dict(
{
'facebook_id': getattr(settings, 'SOCIAL_AUTH_FACEBOOK_KEY', None),
'facebook_scope': ''.join(FacebookOAuth2.DEFAULT_SCOPE),
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS)
}, **extra)
def loginpage_userland(request, username, base):
base = get_object_or_404(Base, name=base)
return render(
request, 'aaa/cas_loginpage.html', {
'userland': username,
'base': base.name,
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS)
})
def template_context_processor(request):
login_methods = []
from social.apps.django_app.utils import BACKENDS
from social.backends import utils
icon_map = {"google": "googleplus"}
return {
"login_backends": [(name, icon_map.get(name, name))
for name in utils.load_backends(BACKENDS)]
}
def context(**extra):
'''
python-social-auth 中用于第三方注册携带信息的重写了的 context
'''
return dict({
'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope': ' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS)
}, **extra)
def signin(req):
from astrometry.net import settings
from social.backends.utils import load_backends
ctxt = RequestContext(req)
ctxt.update({
'available_backends':
load_backends(settings.AUTHENTICATION_BACKENDS)
})
return render_to_response('signin.html', ctxt)
def context(**extra):
return dict(
{
"plus_id": getattr(settings, "SOCIAL_AUTH_GOOGLE_PLUS_KEY", None),
"plus_scope": " ".join(GooglePlusAuth.DEFAULT_SCOPE),
"available_backends": load_backends(settings.AUTHENTICATION_BACKENDS),
},
**extra
)
def setUp(self):
HTTPretty.enable()
Backend = module_member(self.backend_path)
self.strategy = load_strategy()
self.backend = Backend(self.strategy, redirect_uri=self.complete_url)
self.name = self.backend.name.upper().replace('-', '_')
self.complete_url = self.strategy.build_absolute_uri(
self.raw_complete_url.format(self.backend.name)
)
backends = (self.backend_path, )
load_backends(backends, force_load=True)
user_data_body = json.loads(self.user_data_body)
self.email = '*****@*****.**'
user_data_body['email'] = self.email
self.user_data_body = json.dumps(user_data_body)
self.do_rest_login()
def context(**extra):
"""
Adding default context to rendered page.
"""
return dict(
{
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS),
}, **extra)
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
name = self.backend.name
self.complete_url = self.raw_complete_url.format(name)
self.strategy = TestStrategy(self.backend, TestStorage)
name = name.upper().replace('-', '_')
self.strategy.set_settings({
'SOCIAL_AUTH_' + name + '_KEY':
'a-key',
'SOCIAL_AUTH_' + name + '_SECRET':
'a-secret-key',
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS':
(self.backend_path, 'tests.backends.broken_test.BrokenBackendAuth')
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True)
def book(request):
queryset = request.GET
ticket_id = queryset.get('leg_id')
user = request.user
seat = random.choice(["WINDOW", "AISLE"])
ticket = Ticket(ticket_id=ticket_id, owner=user, seat=seat)
ticket.save()
return render(request, 'pages/flights.html',
{'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'messages': ["The ticket was successfully booked", ]})
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
self.strategy = TestStrategy(self.backend, TestStorage)
self.name = self.backend.name.upper().replace('-', '_')
self.complete_url = self.strategy.build_absolute_uri(
self.raw_complete_url.format(self.backend.name))
backends = (self.backend_path,
'social.tests.backends.test_broken.BrokenBackendAuth')
self.strategy.set_settings(
{'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': backends})
self.strategy.set_settings(self.extra_settings())
# Force backends loading to trash PSA cache
load_backends(backends, force_load=True)
User.reset_cache()
TestUserSocialAuth.reset_cache()
TestNonce.reset_cache()
TestAssociation.reset_cache()
TestCode.reset_cache()
def home(req):
upload_form = UploadCampaignForm(req.user)
all_messages = json.dumps([x.message for x in messages.get_messages(req)])
available_backends = load_backends(['social.backends.instagram.InstagramOAuth2'])
if req.user.is_authenticated():
instagram_acct = UserSocialAuth.objects.filter(user=req.user, provider='instagram')
else:
instagram_acct = None
return render(req, "index.html", locals())
def search(request):
client = httplib2.Http()
headers = {
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json'
}
body = {}
endpoint = settings.SKY_SCANNER_API_URL
body["apiKey"] = settings.SKY_SCANNER_API_KEY
queryset = request.GET
if not queryset.get('origin'):
return render(request, 'pages/flights.html',
{'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS)})
body["country"] = queryset.get('country', 'US')
body["currency"] = queryset.get('currency', 'USD')
body["locale"] = queryset.get('currency', 'en-US')
body["originplace"] = queryset.get('origin', 'SFO')
body["destinationplace"] = queryset.get('destination', 'JFK')
body["outbounddate"] = queryset.get('outbounddate', '2015-11-25')
if body["outbounddate"].split('/')[0]:
sep = body["outbounddate"].split('/')
body["outbounddate"] = "-".join([sep[2]] + sep[:2])
body["locationschema"] = queryset.get('locationschema', 'Iata')
body["adults"] = queryset.get('adults', '1')
response, content = client.request(endpoint, "POST", headers=headers, body=urllib.urlencode(body))
second_endpoint = response['location'] + '?apiKey=' + body["apiKey"]
response, content = client.request(second_endpoint, "GET")
context = clean_sky_scanner_data(json.loads(content))
context['query'] = body
return render(request, 'pages/flights.html',
{'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'context': context})
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
name = self.backend.name.upper().replace('-', '_')
self.strategy = TestStrategy(self.backend, TestStorage)
self.complete_url = self.strategy.build_absolute_uri(
'/complete/{0}'.format(name)
)
self.strategy.set_settings({
'SOCIAL_AUTH_{0}_FORM_URL'.format(name): '/login/{0}'.format(name),
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
self.backend_path,
'social.tests.backends.broken_test.BrokenBackendAuth'
)
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True
)
def build_context(request):
urls = {
'login_page': reverse('login'),
'logout': reverse('logout'),
}
return {'ctx': {
'auth_backends': list(load_backends(settings.AUTHENTICATION_BACKENDS).keys()),
'urls': urls,
'DEBUG': settings.DEBUG,
# 'MEDIA_HASH': settings.MEDIA_HASH,
}}
def context(**extra):
return dict(
{
# 'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
# 'plus_scope': ' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS),
'PLANET_VERSION': TUMBO_VERSION,
'TUMBO_STATIC_CACHE_SECONDS': settings.TUMBO_STATIC_CACHE_SECONDS
},
**extra)
def setUp(self):
HTTPretty.enable()
self.backend = module_member(self.backend_path)
name = self.backend.name
self.complete_url = self.raw_complete_url.format(name)
self.strategy = TestStrategy(self.backend, TestStorage)
name = name.upper().replace('-', '_')
self.strategy.set_settings({
'SOCIAL_AUTH_' + name + '_KEY': 'a-key',
'SOCIAL_AUTH_' + name + '_SECRET': 'a-secret-key',
'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
self.backend_path,
'social.tests.backends.broken_test.BrokenBackendAuth'
)
})
# Force backends loading to trash PSA cache
load_backends(
self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'),
force_load=True
)
def home(req):
upload_form = UploadCampaignForm(req.user)
all_messages = json.dumps([x.message for x in messages.get_messages(req)])
available_backends = load_backends(
['social.backends.instagram.InstagramOAuth2'])
if req.user.is_authenticated():
instagram_acct = UserSocialAuth.objects.filter(user=req.user,
provider='instagram')
else:
instagram_acct = None
return render(req, "index.html", locals())
def get_context_data(self, **kwargs):
context = super(AvailableBackendsMixin,
self).get_context_data(**kwargs)
return dict(
{
'plus_id':
getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope':
' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends':
load_backends(settings.AUTHENTICATION_BACKENDS)
}, **context)
def __init__(self, *args, **kwargs):
backends_by_name = load_backends(settings.AUTHENTICATION_BACKENDS)
self.social_state_keys = []
self.auth_complete_paths = []
for backend_name in backends_by_name.keys():
self.social_state_keys.append("{}_state".format(backend_name))
self.auth_complete_paths.append(
reverse("social:complete", kwargs={'backend': backend_name}))
super(DjangoTenantStrategy, self).__init__(*args, **kwargs)
def forms(request):
return {
'reg_form': render_to_string(
'forms/form.html', {'form': RegUserForm()}
),
'login_form': render_to_string(
'forms/form.html', {'form': LoginForm()}
),
'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope': ' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
}
def get_context_data(self, **kwargs):
"""Ensure that 'next' gets passed along"""
LOGGER.debug('socialprofile.views.SelectAuthView.get_context_data')
next_url = self.request.GET.get(REDIRECT_FIELD_NAME, DEFAULT_RETURNTO_PATH)
context = super(SelectAuthView, self).get_context_data(**kwargs)
context['next_param'] = REDIRECT_FIELD_NAME
context['next_url'] = next_url
context['plus_id'] = getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None)
context['plus_scope'] = ' '.join(GooglePlusAuth.DEFAULT_SCOPE)
context['available_backends'] = load_backends(settings.AUTHENTICATION_BACKENDS)
return context
def pals(request):
queryset = request.GET
ticket_id = queryset.get('leg_id')
tickets = Ticket.objects.filter(ticket_id=ticket_id)
users = []
for ticket in tickets:
owner = ticket.owner
users.append(owner)
return render(request, 'pages/pals.html',
{'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'pals': users})
def similar_backends(context):
backends = load_backends(settings.AUTHENTICATION_BACKENDS)
user = context.get('user')
secondary_users = SecondaryEmail.objects.filter(email=user.email).exclude(
user=user)
similar_users = defaultdict(list)
for secondary in secondary_users:
similar_users[secondary.user].append(
(secondary.provider.provider,
backends.get(secondary.provider.provider)))
similar_users = dict(similar_users)
context['similar_users'] = similar_users
return ''
def build_context(request):
urls = {
'login_page': reverse('login'),
'logout': reverse('logout'),
}
return {
'ctx': {
'auth_backends':
list(load_backends(settings.AUTHENTICATION_BACKENDS).keys()),
'urls':
urls,
'DEBUG':
settings.DEBUG,
# 'MEDIA_HASH': settings.MEDIA_HASH,
}
}
def forms(request):
plp_url = settings.PLP_URL
# мы хотим, чтобы url PLP в шаблонах был наверняка со слэшом в конце
if settings.PLP_URL[-1] != '/':
plp_url = "{}/".format(plp_url)
return {
'login_form': render_to_string('forms/form.html',
{'form': LoginForm()}),
'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope': ' '.join(GooglePlusAuth.DEFAULT_SCOPE),
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
'plp_url': plp_url,
'social_facebook': getattr(settings, 'SOCIAL_ACCOUNT_FACEBOOK', '#'),
'social_vk': getattr(settings, 'SOCIAL_ACCOUNT_VK', '#'),
'social_ok': getattr(settings, 'SOCIAL_ACCOUNT_OK', '#'),
'social_instagram': getattr(settings, 'SOCIAL_ACCOUNT_INSTAGRAM', '#'),
'social_twitter': getattr(settings, 'SOCIAL_ACCOUNT_TWITTER', '#'),
}
def weblate_login(request):
'''
Login handler, just wrapper around login.
'''
# Redirect logged in users to profile
if request.user.is_authenticated():
return redirect('profile')
return auth_views.login(
request,
template_name='accounts/login.html',
authentication_form=LoginForm,
extra_context={
'login_backends':
[x for x in load_backends(BACKENDS).keys() if x != 'email'],
'title':
_('Login'),
})
def custom_login(request):
"""
Custom login to integrate social auth and default login.
"""
username = password = ''
logout(request)
kwargs = dict(
available_backends=load_backends(settings.AUTHENTICATION_BACKENDS))
if request.POST:
params = request.POST
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return redirect(request.POST.get('next', '/ct/'))
else:
params = request.GET
if 'next' in params: # must pass through for both GET or POST
kwargs['next'] = params['next']
return render_to_response('psa/custom_login.html',
context_instance=RequestContext(request, kwargs))
