def auth_success_response(user, pgt, proxies):
response = etree.Element(CAS + 'serviceResponse', nsmap=NSMAP)
auth_success = etree.SubElement(response, CAS + 'authenticationSuccess')
username = etree.SubElement(auth_success, CAS + 'user')
username.text = getattr(user, settings.CAS_USERNAME_FIELD)
if len(username.text) > 30:
if '@' in username.text[:30]:
username.text = username.text[:30]
elif username.text.endswith('@touchstonenetwork.net'):
username.text = username.text.rsplit(
'@touchstonenetwork.net')[0][:27] + '@tn'
else:
username.text = username.text[:29] + '@'
if settings.CAS_CUSTOM_ATTRIBUTES_CALLBACK:
callback = get_callable(settings.CAS_CUSTOM_ATTRIBUTES_CALLBACK)
attrs = callback(user)
if len(attrs) > 0:
formater = get_callable(settings.CAS_CUSTOM_ATTRIBUTES_FORMATER)
formater(auth_success, attrs)
if pgt:
pgtElement = etree.SubElement(auth_success,
CAS + 'proxyGrantingTicket')
pgtElement.text = pgt
if proxies:
proxiesElement = etree.SubElement(auth_success, CAS + "proxies")
for proxy in proxies:
proxyElement = etree.SubElement(proxiesElement, CAS + "proxy")
proxyElement.text = proxy
return unicode(etree.tostring(response, encoding='utf-8'), 'utf-8')
def test_exceptions(self):
# A missing view (identified by an AttributeError) should raise
# ViewDoesNotExist, ...
with six.assertRaisesRegex(self, ViewDoesNotExist, ".*View does not exist in.*"):
get_callable('urlpatterns_reverse.views.i_should_not_exist')
# ... but if the AttributeError is caused by something else don't
# swallow it.
with self.assertRaises(AttributeError):
get_callable('urlpatterns_reverse.views_broken.i_am_broken')
def _set_attr(self, prefix_name, value):
name = prefix_name[len(self.prefix) + 1:]
if name in ('ROUTER', ):
try:
obj = import_by_name(value)
except (ImportError, ValueError, AttributeError):
raise ImportError(
f"Cannot import '{value}'. Check your settings.{prefix_name}"
)
setattr(self, name, obj)
return obj
elif name in ('get_current_user', 'get_current_request',
'get_current_user'):
try:
if isinstance(value, str):
func = get_callable(value)
elif callable(value):
func = value
else:
raise ImproperlyConfigured(
f"{value} is not a valid value for `{name}`. "
"It must be a callable or a fullpath to callable. ")
except Exception as e:
raise ImproperlyConfigured(e)
setattr(self, name, func)
return func
else:
setattr(self, name, value)
return value
def render(self, context):
"""
Render the view node
"""
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = URLResolver(r'^/', urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
# pylint: disable=bare-except
except:
view = get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
render_fnc = view(context['request'], *args, **kwargs).content.\
decode('unicode_escape')
return render_fnc
raise "%r is not callable" % view
# pylint: disable=bare-except
except:
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
return ""
def auth_success_response(user, pgt, proxies):
response = etree.Element(CAS + 'serviceResponse', nsmap=NSMAP)
auth_success = etree.SubElement(response, CAS + 'authenticationSuccess')
username = etree.SubElement(auth_success, CAS + 'user')
username.text = user.username
attrs = {}
for receiver, custom in signals.cas_collect_custom_attributes.send(sender=auth_success_response, user=user):
if custom:
attrs.update(custom)
identifiers = [i for sr, rr in signals.on_cas_collect_histories.send(sender=validate, for_user=user)
for i in rr]
if identifiers:
# Singular `identifier`, as that is the name of the element tag(s).
attrs['identifier'] = identifiers
if attrs:
formatter = get_callable(settings.CAS_CUSTOM_ATTRIBUTES_FORMATER)
formatter(auth_success, attrs)
if pgt:
pgtElement = etree.SubElement(auth_success, CAS + 'proxyGrantingTicket')
pgtElement.text = pgt
if proxies:
proxiesElement = etree.SubElement(auth_success, CAS + "proxies")
for proxy in proxies:
proxyElement = etree.SubElement(proxiesElement, CAS + "proxy")
proxyElement.text = proxy
return etree.tostring(response, encoding='unicode')
def _load_emails(self):
loader = getattr(
settings,
"DEC_LOADER",
"disposable_email_checker.emails.email_domain_loader",
)
return get_callable(loader)()
def render(self, context):
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = URLResolver(RegexPattern(r'^/'), urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
return view(context['request'], *args,
**kwargs).content.decode(settings.DEFAULT_CHARSET)
raise "%r is not callable" % view
except:
if getattr(settings, 'TEMPLATE_DEBUG', False):
raise
return ""
def render(self, context):
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = urls.RegexURLResolver(r'^/', urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
# view = urls.get_callable(url_or_view, True)
view = urls.get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
return view(context['request'], *args, **kwargs).content
raise "%r is not callable" % view
except:
# if settings.TEMPLATE_DEBUG:
raise
return ""
def render(self, context):
""" Effectuer le rendu du nœud """
# Renvoyer chaîne vide si aucune variable request à passer
if 'request' not in context:
return ''
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = urls.RegexURLResolver(r'^/', urlconf)
kwargs = {
key: Variable(value).resolve(context)
for (key, value) in self.kwargs.items()
}
url_or_view = urls.reverse(url_or_view, kwargs=kwargs)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = urls.get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {
key: Variable(value).resolve(context)
for key, value in self.kwargs.items()
}
if callable(view):
output = view(request, *args, **kwargs)
return getattr(output, 'content', output)
if settings.TEMPLATE_DEBUG:
output = (_(
"%(viewname)r is not a method or function and cannot be called"
) % {
'viewname': view
})
raise ViewDoesNotExist(output)
return ''
def can_url(user, view):
"""
Tests whether the given user would have access to the view. The view can
be a callable, importable text path or a view name, possibly with the
namespace prefix ('namespace:view_name'). The view function must be
decorated with the can_url_func (that's what UrlPatterns class does).
"""
if ':' not in view:
view = get_callable(view)
if not callable(view):
callbacks = get_all_callbacks(get_urlconf())
if view not in callbacks:
raise NoReverseMatch("Reverse for '%s' not found." % view)
view = callbacks[view]
if not hasattr(view, 'can_url_func'):
raise NoReverseMatch(
"Reverse for '%s' is not decorated with permissions." % view)
try:
return view.can_url_func(user)
except PermissionDenied:
return False
def oauth_user_auth(request):
oauth_server, oauth_request = initialize_server_request(request)
if oauth_request is None:
return INVALID_PARAMS_RESPONSE
try:
token = oauth_server.fetch_request_token(oauth_request)
except oauth.OAuthError as err:
return send_oauth_error(err)
try:
callback = oauth_server.get_callback(oauth_request)
except:
callback = None
if request.method == "GET":
params = oauth_request.get_normalized_parameters()
oauth_view = getattr(settings, 'OAUTH_AUTH_VIEW', None)
if oauth_view is None:
return oauth_auth_view(request, token, callback, params)
else:
return get_callable(oauth_view)(request, token, callback, params)
elif request.method == "POST":
try:
form = forms.OAuthAuthenticationForm(request.POST)
if form.is_valid():
token = oauth_server.authorize_token(token, request.user)
args = '?'+token.to_string(only_key=True)
else:
args = '?error=%s' % 'Access not granted by user.'
if not callback:
callback = getattr(settings, 'OAUTH_CALLBACK_VIEW')
return get_callable(callback)(request, token)
response = HttpResponseRedirect(callback+args)
except oauth.OAuthError as err:
response = send_oauth_error(err)
else:
response = HttpResponse('Action not allowed.')
return response
def error_view(status_code):
if status_code == 4031:
return get_callable(settings.CSRF_FAILURE_VIEW)
if status_code == 500:
return handle_500
exceptions = {
400: SuspiciousOperation,
403: PermissionDenied,
404: Http404,
}
exception = exceptions[status_code]
def error_view(request, *args, **kwargs):
raise exception
return error_view
def get_payment_modules(self, request=None):
"""
Import and return all payment modules defined in
``PLATA_PAYMENT_MODULES``
If request is given only applicable modules are loaded.
"""
all_modules = [
get_callable(module)(self)
for module in plata.settings.PLATA_PAYMENT_MODULES
]
if not request:
return all_modules
return [
module for module in all_modules
if module.enabled_for_request(request)
]
def fallback_view(self, request):
"""
Runs the fallback view function in ``settings.MULTISITE_FALLBACK``.
If ``MULTISITE_FALLBACK`` is None, raises an Http404 error.
If ``MULTISITE_FALLBACK`` is callable, will treat that
callable as a view that returns an HttpResponse.
If ``MULTISITE_FALLBACK`` is a string, will resolve it to a
view that returns an HttpResponse.
In order to use a generic view that takes additional
parameters, ``settings.MULTISITE_FALLBACK_KWARGS`` may be a
dictionary of additional keyword arguments.
"""
fallback = getattr(settings, 'MULTISITE_FALLBACK', None)
if fallback is None:
raise Http404
if callable(fallback):
view = fallback
else:
try:
view = get_callable(fallback)
if django.VERSION < (1,8):
# older django's get_callable falls through on error,
# returning the input as output
# which notably is definitely not a callable here
if not callable(view):
raise ImportError()
except ImportError:
# newer django forces this to be an error, which is tidier.
# we rewrite the error to be a bit more helpful to our users.
raise ImproperlyConfigured(
'settings.MULTISITE_FALLBACK is not callable: %s' %
fallback
)
kwargs = getattr(settings, 'MULTISITE_FALLBACK_KWARGS', {})
if hasattr(view, 'as_view'):
# Class-based view
return view.as_view(**kwargs)(request)
# View function
return view(request, **kwargs)
def _set_attr(self, prefix_name, value):
name = prefix_name[len(self.prefix) + 1:]
if name in ('GET_CACHE_KEY', 'GET_CACHE_VERSION'):
try:
if isinstance(value, str):
func = get_callable(value)
elif callable(value):
func = value
else:
raise ImproperlyConfigured(
f"{value} is not a valid value for `{name}`. "
"It must be a callable or a fullpath to callable. ")
except Exception as e:
raise ImproperlyConfigured(e)
setattr(self, name, func)
return func
else:
setattr(self, name, value)
return value
def fallback_view(self, request):
"""
Runs the fallback view function in ``settings.MULTISITE_FALLBACK``.
If ``MULTISITE_FALLBACK`` is None, raises an Http404 error.
If ``MULTISITE_FALLBACK`` is callable, will treat that
callable as a view that returns an HttpResponse.
If ``MULTISITE_FALLBACK`` is a string, will resolve it to a
view that returns an HttpResponse.
In order to use a generic view that takes additional
parameters, ``settings.MULTISITE_FALLBACK_KWARGS`` may be a
dictionary of additional keyword arguments.
"""
fallback = getattr(settings, 'MULTISITE_FALLBACK', None)
if fallback is None:
raise Http404
if callable(fallback):
view = fallback
else:
try:
view = get_callable(fallback)
if django.VERSION < (1, 8):
# older django's get_callable falls through on error,
# returning the input as output
# which notably is definitely not a callable here
if not callable(view):
raise ImportError()
except ImportError:
# newer django forces this to be an error, which is tidier.
# we rewrite the error to be a bit more helpful to our users.
raise ImproperlyConfigured(
'settings.MULTISITE_FALLBACK is not callable: %s' %
fallback)
kwargs = getattr(settings, 'MULTISITE_FALLBACK_KWARGS', {})
if hasattr(view, 'as_view'):
# Class-based view
return view.as_view(**kwargs)(request)
# View function
return view(request, **kwargs)
def render(self, context):
""" Effectuer le rendu du nœud """
# Renvoyer chaîne vide si aucune variable request à passer
if 'request' in context:
request = context['request']
view = urls.get_callable(Variable(self.view).resolve(context))
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {
key: Variable(value).resolve(context)
for key, value in self.kwargs.items()
}
if callable(view):
output = view(request, *args, **kwargs)
return getattr(output, 'content', output)
elif settings.TEMPLATE_DEBUG:
output = _(
"{viewname} is not a method or function and cannot be called"
).format(viewname=view)
raise ViewDoesNotExist(output)
return ""
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return "%s%s" % (get_script_prefix(), paths)
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
try:
lookup_view = get_callable(lookup_view)
except (ImportError, ViewDoesNotExist):
# Emulate can_fail=True from earlier django versions.
pass
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
# The monkey patch is right here: we need to cope with 'possibilities'
# being a list of tuples with 2 or 3 elements.
for possibility_data in possibilities:
possibility = possibility_data[0]
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except Exception:
return None
def fix_references(fn, view_names):
new_content = []
with open(fn, 'r') as code:
for line in code:
m = dot_ref_re.search(line)
if m:
dotted = m.group('dotted')
viewfunc = get_callable(dotted)
newline = line.replace(dotted, view_names[viewfunc])
else:
newline = line
new_content.append(newline)
m = function_reverse_re.search(line)
if m:
print("function reference reverse() in ", fn)
m = no_namespace_tag_re.search(line)
if m:
print("no namespace on {% url %} in ", fn)
with open(fn, 'w') as py:
py.write(''.join(new_content))
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return '%s%s' % (get_script_prefix(), paths)
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except:
return None
RetrieveUpdateDestroyProfileValidationSerializer,
)
from simple_login.views.base import (
BaseAPIView,
ProfileBaseAPIView,
AuthenticatedRequestBaseAPIView,
)
from simple_login import models
from simple_login.utils.otp import OTPHandler
from simple_login.utils.auth import AuthMethod
from simple_login.utils import social
from simple_login.utils.user import UserHelpers
from simple_login import serializers
SERIALIZER = get_callable(settings.AUTH_USER_SERIALIZER) if hasattr(settings, 'AUTH_USER_SERIALIZER') else \
serializers.AuthUserSerializer
def get_unique_username(user_model, username_desired, append_id=0):
username = username_desired
if user_model.objects.filter(username=username).count() > 0:
username = '******'.format(username, append_id)
get_unique_username(user_model, username, append_id)
return username
def download_and_set_photo(url, instance, field, is_facebook=False):
if is_facebook:
filename = url.split('?')[0].split('/')[-1]
else:
url(r'^api/auth-n/',
include('rest_framework.urls', namespace='rest_framework')),
]
if settings.DEBUG:
from django.views import defaults as dj_default_views
from django.urls import get_callable
urlpatterns += [
url(r'^400/$',
dj_default_views.bad_request,
kwargs={'exception': Exception('Bad Request!')}),
url(r'^403/$',
dj_default_views.permission_denied,
kwargs={'exception': Exception('Permission Denied!')}),
url(r'^403_csrf/$', get_callable(settings.CSRF_FAILURE_VIEW)),
url(r'^404/$',
dj_default_views.page_not_found,
kwargs={'exception': Exception('Not Found!')}),
url(r'^500/$', handler500),
]
# Django Debug Toolbar
try:
import debug_toolbar
urlpatterns += [
url(r'^__debug__/', include(debug_toolbar.urls)),
]
except ImportError:
pass
def _render_throttling(self, request, exception):
return get_callable(settings.THROTTLING_FAILURE_VIEW)(request,
exception)
def getEditorClass():
global _EditorClass
if not _EditorClass:
_EditorClass = get_callable(settings.EDITOR)
return _EditorClass
def get_disabled_view():
module = settings.FEATUREFLAGS_DISABLED_VIEW
return get_callable(module)
def test_view_loading(self):
self.assertEqual(get_callable('urlpatterns_reverse.views.empty_view'), empty_view)
# passing a callable should return the callable
self.assertEqual(get_callable(empty_view), empty_view)
def _get_failure_view():
"""
Returns the view to be used for CSRF rejections
"""
return get_callable(settings.CSRF_FAILURE_VIEW)
# return datetime.datetime(d.year, 1, 1, 0, 0, 0, 0, pytz.timezone(settings.TIME_ZONE))
#
#
# def get_end_of_this_year():
# d = datetime.datetime.today()
# return datetime.datetime(d.year + 1, 1, 1, 0, 0, 0, 0, pytz.timezone(settings.TIME_ZONE))
import datetime
"""
Documented
"""
# a function to control be dbfield on all instances, Saves you time to subclass ifonly you need to add a help text or something
RA_FORMFIELD_FOR_DBFIELD_FUNC = getattr(
settings, 'RA_FORMFIELD_FOR_DBFIELD_FUNC',
'ra.base.helpers.default_formfield_for_dbfield')
RA_FORMFIELD_FOR_DBFIELD_FUNC = get_callable(RA_FORMFIELD_FOR_DBFIELD_FUNC)
# ------
# Navigation class
RA_NAVIGATION_CLASS = getattr(settings, 'RA_NAVIGATION_CLASS',
'ra.utils.navigation.RaSuitMenu')
"""
UnDocumented
"""
RA_ENABLE_ADMIN_DELETE_ALL = getattr(settings, 'RA_ENABLE_ADMIN_DELETE_ALL',
False)
# RA_DEFAULT_FROM_DATETIME = lazy(get_first_of_this_year, datetime.datetime)()
# RA_DEFAULT_TO_DATETIME = lazy(get_end_of_this_year, datetime.datetime)()
# # models
def build_views(self):
for view_str in self.view_list:
view = get_callable(view_str)
view(_exporting_event=self._exporting_event).build_method()
except ImportError as e:
raise ImportError(
'Failed to import class "%s" from module "%s". Reason: %s.' %
(klass, module, e))
try:
klass = getattr(module, klass)
except AttributeError:
raise AttributeError('Module "%s" does not define a "%s" class.' %
(module.__name__, klass))
return klass
# Make use of django-autoslug compatible slugify function.
slugify = getattr(settings, 'AUTOSLUG_SLUGIFY_FUNCTION', None)
if not slugify:
try:
from unidecode import unidecode
slugify = lambda s: unidecode(s).replace(' ', '-')
except ImportError:
try:
from pytils.translit import slugify
except ImportError:
slugify = 'django.template.defaultfilters.slugify'
if isinstance(slugify, six.string_types):
from django.urls import get_callable
slugify = get_callable(slugify)
if settings.API_DEBUG:
urlpatterns += [
# Browsable API
url('^schema/$', api_schemas.schema_view, name='schema'),
url(r'^api-playground/$', api_schemas.swagger_schema_view, name='api-playground'),
url(r'^api/auth-n/', include('rest_framework.urls', namespace='rest_framework')),
]
if settings.DEBUG:
from django.views import defaults as dj_default_views
from django.urls import get_callable
urlpatterns += [
url(r'^400/$', dj_default_views.bad_request, kwargs={'exception': Exception('Bad Request!')}),
url(r'^403/$', dj_default_views.permission_denied, kwargs={'exception': Exception('Permission Denied!')}),
url(r'^403_csrf/$', get_callable(settings.CSRF_FAILURE_VIEW)),
url(r'^404/$', dj_default_views.page_not_found, kwargs={'exception': Exception('Not Found!')}),
url(r'^500/$', handler500),
]
# Django Debug Toolbar
try:
import debug_toolbar
urlpatterns += [url(r'^__debug__/', include(debug_toolbar.urls)), ]
except ImportError:
pass
# Livereloading
try:
from devrecargar.urls import urlpatterns as devrecargar_urls
urlpatterns += [url(r'^devrecargar/', include((devrecargar_urls, 'devrecargar', ), namespace='devrecargar'))]
def user_authorization(request, form_class=AuthorizeRequestTokenForm):
oauth_token = request.POST.get('oauth_token',
request.GET.get('oauth_token'))
if not oauth_token:
return HttpResponseBadRequest('No request token specified.')
oauth_request = get_oauth_request(request)
try:
request_token = store.get_request_token(request, oauth_request,
oauth_token)
except InvalidTokenError:
return HttpResponseBadRequest('Invalid request token.')
consumer = store.get_consumer_for_request_token(request, oauth_request,
request_token)
if request.method == 'POST':
form = form_class(request.POST)
if request.session.get('oauth',
'') == request_token.key and form.is_valid():
request.session['oauth'] = ''
if form.cleaned_data['authorize_access']:
request_token = store.authorize_request_token(
request, oauth_request, request_token)
args = {'oauth_token': request_token.key}
else:
args = {'error': _('Access not granted by user.')}
if request_token.callback is not None and request_token.callback != OUT_OF_BAND:
callback_url = request_token.get_callback_url(args)
if UNSAFE_REDIRECTS:
response = UnsafeRedirect(callback_url)
else:
response = HttpResponseRedirect(callback_url)
else:
# try to get custom callback view
callback_view_str = getattr(
settings, OAUTH_CALLBACK_VIEW,
'oauth_provider.views.fake_callback_view')
try:
view_callable = get_callable(callback_view_str)
except AttributeError:
raise Exception("%s view doesn't exist." %
callback_view_str)
# try to treat it as Class Based View (CBV)
try:
callback_view = view_callable.as_view()
except AttributeError:
# if it appears not to be CBV treat it like FBV
callback_view = view_callable
response = callback_view(request, **args)
else:
response = send_oauth_error(oauth.Error(_('Action not allowed.')))
else:
# try to get custom authorize view
authorize_view_str = getattr(
settings, OAUTH_AUTHORIZE_VIEW,
'oauth_provider.views.fake_authorize_view')
try:
view_callable = get_callable(authorize_view_str)
except AttributeError:
raise Exception("%s view doesn't exist." % authorize_view_str)
# try to treat it as Class Based View (CBV)
try:
authorize_view = view_callable.as_view()
except AttributeError:
# if it appears not to be CBV treat it like FBV
authorize_view = view_callable
params = oauth_request.get_normalized_parameters()
# set the oauth flag
request.session['oauth'] = request_token.key
response = authorize_view(request, request_token,
request_token.get_callback_url(), params)
return response
def _render_throttling(self, request, exception):
return get_callable(settings.THROTTLING_FAILURE_VIEW)(request, exception)
def _get_failure_view():
"""
Returns the view to be used for CSRF rejections
"""
return get_callable(settings.CSRF_FAILURE_VIEW)
# Only translate the urls if `TRANSLATE_URLS` is `True`.
if getattr(settings, 'TRANSLATE_URLS', False):
_ = ugettext_lazy
else:
def _(s):
return s
auth_login_form = getattr(
settings,
'INCUNA_AUTH_LOGIN_FORM',
'django.contrib.auth.forms.AuthenticationForm',
)
auth_form = get_callable(auth_login_form)
password_reset_form = getattr(
settings,
'INCUNA_PASSWORD_RESET_FORM',
'incuna_auth.forms.CrispyPasswordResetForm',
)
reset_form = get_callable(password_reset_form)
urlpatterns = [
url(
_(r'^login/$'),
views.LoginView.as_view(authentication_form=auth_form),
name='login',
),
url(
from django.conf import settings
from django.contrib.staticfiles import finders
from django.core import mail
from django.core.exceptions import ValidationError
from django.core.files.storage import DefaultStorage, default_storage
from django.core.files.uploadedfile import InMemoryUploadedFile
from django.template.loader import render_to_string
from django.urls import get_callable, reverse
from django.utils.html import format_html
from premailer import transform
from resizeimage.resizeimage import resize_contain
slugify_function_path = \
getattr(settings, 'AUTOSLUG_SLUGIFY_FUNCTION', 'autoslug.utils.slugify')
slugify = get_callable(slugify_function_path)
def client_ip_from_request(request):
"""Returns the IP of the request, accounting for the possibility of being behind a proxy.
"""
ip = request.META.get("HTTP_X_FORWARDED_FOR", None)
if ip:
# X_FORWARDED_FOR returns client1, proxy1, proxy2,...
ip = ip.split(", ")[0]
else:
ip = request.META.get("REMOTE_ADDR", "")
return ip
class OriginSettingsObject(object):
def render_inertia(request, component_name, props=None, template_name=None):
"""
Renders either an HttpRespone or JsonResponse of a component for
the use in an InertiaJS frontend integration.
"""
inertia_template = None
inertia_template = getattr(settings, "INERTIA_TEMPLATE", "base.html")
if template_name is not None:
inertia_template = template_name
if inertia_template is None:
raise ImproperlyConfigured(
"No Inertia template found. Either set INERTIA_TEMPLATE"
"in settings.py or pass template parameter."
)
# share custom data or default authenticated user
share_method_path = getattr(settings, "INERTIA_SHARE", "inertia.share.share_auth")
if share_method_path:
share_method = get_callable(share_method_path)
share_method(request)
if props is None:
props = {}
shared = {}
if hasattr(request, "session"):
for k, v in request.session.get("share", {}).items():
log.debug((k,v))
shared[k]=v
props.update(shared)
for key in ("success", "error", "errors"):
if hasattr(request, "session") and request.session.get(key):
del request.session[key]
# subsequent renders
inertia_version = get_version()
is_version_correct = 'X-Inertia-Version' in request.headers and \
request.headers["X-Inertia-Version"] == str(inertia_version)
# check if partial reload is requested
only_props = request.headers.get("X-Inertia-Partial-Data", [])
if (
only_props
and request.headers.get("X-Inertia-Partial-Component", "") == component_name
):
_props = {}
for key in props:
if key in only_props:
_props.update({key: props[key]})
else:
_props = props
# lazy load props and make request available to props being lazy loaded
load_lazy_props(_props, request)
if 'X-Inertia' in request.headers:
response = JsonResponse({
"component": component_name,
"props": _props,
"version": inertia_version,
"url": request.get_full_path()
})
response['X-Inertia'] = True
response['Vary'] = 'Accept'
return response
context = _build_context(component_name, _props,
inertia_version,
url=request.get_full_path())
return render(request, inertia_template, context)
if settings.DEBUG:
from django.urls import get_callable
from django.views import defaults as dj_default_views
urlpatterns += [
path(
"400/",
dj_default_views.bad_request,
kwargs={"exception": Exception("Bad Request!")},
),
path(
"403/",
dj_default_views.permission_denied,
kwargs={"exception": Exception("Permission Denied!")},
),
path("403_csrf/", get_callable(settings.CSRF_FAILURE_VIEW)),
path(
"404/",
dj_default_views.page_not_found,
kwargs={"exception": Exception("Not Found!")},
),
path("500/", handler500),
]
urlpatterns += static(settings.MEDIA_URL,
document_root=settings.MEDIA_ROOT)
# Django Debug Toolbar
if "debug_toolbar" in settings.INSTALLED_APPS:
import debug_toolbar
if settings.DEBUG:
from django.views import defaults as dj_default_views
from django.urls import get_callable
# ERROR URLs
# --------------------------------------------------------------------------
urlpatterns += [
url(r'^400/$',
dj_default_views.bad_request,
kwargs={'exception': Exception('Bad Request.')}),
url(r'^403/$',
dj_default_views.permission_denied,
kwargs={'exception': Exception('Permission Denied.')}),
url(r'^403_csrf/$',
get_callable(settings.CSRF_FAILURE_VIEW)),
url(r'^404/$',
dj_default_views.page_not_found,
kwargs={'exception': Exception('Page Not Found.')}),
url(r'^500/$',
dj_default_views.server_error),
]
# django-debug-toolbar URLs
# --------------------------------------------------------------------------
try:
import debug_toolbar
urlpatterns += [
url(r'^__debug__/', include(debug_toolbar.urls)),
]
except ImportError: