def auth_success_response(user, pgt, proxies):
etree.register_namespace('cas', CAS_URI)
response = etree.Element(CAS + 'serviceResponse')
auth_success = etree.SubElement(response, CAS + 'authenticationSuccess')
username = etree.SubElement(auth_success, CAS + 'user')
username.text = user.username
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 register_extensions(cls, *extensions):
if not hasattr(cls, '_profile_extensions'):
cls._profile_extensions = set()
here = cls.__module__.split('.')[:-1]
here_path = '.'.join(here + ['extensions'])
for ext in extensions:
if ext in cls._profile_extensions:
continue
try:
if isinstance(ext, basestring):
try:
fn = get_callable(ext + '.register', False)
except ImportError:
fn = get_callable('%s.%s.register' % (here_path, ext), False)
# Not a string, so take our chances and just try to access "register"
else:
fn = ext.register
cls.register_extension(fn)
cls._profile_extensions.add(ext)
except Exception:
raise
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 _get_filters():
"""Returns a list of filters to provide through Jinja. This includes
ported versions of Django's builtin filters that Jinja is lacking,
as well as custom filters as specified by the user in the settings.
:return: A mapping of names to filters.
"""
from django.conf import settings
from coffin.template import builtins
filters = {}
# start with our default builtins
for lib in builtins:
if hasattr(lib, 'jinja2_filters'):
filters.update(lib.jinja2_filters)
# add the globally defined filter list
user = getattr(settings, 'JINJA2_FILTERS', {})
from django.core.urlresolvers import get_callable
if isinstance(user, dict):
for key, value in user.items():
filters[user] = callable(value) and value or get_callable(value)
else:
for value in user:
value = callable(value) and value or get_callable(value)
filters[value.__name__] = value
# add filters defined in application's templatetag libraries
for lib in _get_templatelibs():
if hasattr(lib, 'jinja2_filters'):
filters.update(lib.jinja2_filters)
return filters
def process(self, request):
page_url = self.parent.get_absolute_url()
# Get the rest of the URL
# Provide a way for appcontent items to customize URL processing by
# altering the perceived path of the page:
if "path_mapper" in self.app_config:
path_mapper = urlresolvers.get_callable(self.app_config["path_mapper"])
path, page_url = path_mapper(
request.path,
page_url,
appcontent_parameters=self.parameters
)
else:
path = re.sub('^' + re.escape(page_url[:-1]), '', request.path)
# Change the prefix and urlconf for the monkey-patched reverse function ...
_local.urlconf = (self.urlconf_path, page_url)
try:
fn, args, kwargs = resolve(path, self.urlconf_path)
except (ValueError, Resolver404):
del _local.urlconf
raise Resolver404
#: Variables from the ApplicationContent parameters are added to request
# so we can expose them to our templates via the appcontent_parameters
# context_processor
request._feincms_appcontent_parameters.update(self.parameters)
view_wrapper = self.app_config.get("view_wrapper", None)
if view_wrapper:
fn = partial(
urlresolvers.get_callable(view_wrapper),
view=fn,
appcontent_parameters=self.parameters
)
try:
output = fn(request, *args, **kwargs)
except:
# We want exceptions to propagate, but we cannot allow the
# modifications to reverse() to stay here.
del _local.urlconf
raise
# ... and restore it after processing the view
del _local.urlconf
if isinstance(output, HttpResponse):
if output.status_code == 200:
if not getattr(output, 'standalone', False):
request._feincms_applicationcontents[self.id] = mark_safe(output.content.decode('utf-8'))
return output
else:
request._feincms_applicationcontents[self.id] = mark_safe(output)
def user_authorization(request, form_class=AuthorizeRequestTokenForm):
if 'oauth_token' not in request.REQUEST:
return oauth_error_response('No request token specified.', status_code=httplib.BAD_REQUEST)
oauth_request = get_oauth_request(request)
try:
request_token = store.get_request_token(request, oauth_request, request.REQUEST['oauth_token'])
except InvalidTokenError:
return oauth_error_response('Invalid request token.', status_code=httplib.BAD_REQUEST)
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.name = form.cleaned_data.get("client_name", getattr(settings, "OAUTH_PROVIDER_TOKEN_DEFAULT_NAME", "Unnamed"))
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:
response = HttpResponseRedirect('%s&%s' % (request_token.get_callback_url(), urlencode(args)))
else:
# try to get custom callback view
if request_token.callback == OUT_OF_BAND:
callback_view_str = getattr(settings, OAUTH_PROVIDER_OUT_OF_BAND_CALLBACK_VIEW,
'oauth_provider.views.fake_out_of_band_callback_view')
else:
# try to get custom callback view
callback_view_str = getattr(settings, OAUTH_PROVIDER_CALLBACK_VIEW,
'oauth_provider.views.fake_callback_view')
try:
callback_view = get_callable(callback_view_str)
except AttributeError:
raise Exception, "%s view doesn't exist." % callback_view_str
response = callback_view(request, request_token, **args)
else:
response = oauth_error_response(oauth.Error(_('Action not allowed.')))
else:
# try to get custom authorize view
authorize_view_str = getattr(settings, OAUTH_PROVIDER_AUTHORIZE_VIEW,
'oauth_provider.views.default_authorize_view')
try:
authorize_view = get_callable(authorize_view_str)
except AttributeError:
raise Exception, "%s view doesn't exist." % authorize_view_str
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 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 from_setting(setting):
retval = {}
setting = getattr(settings, setting, {})
if isinstance(setting, dict):
for key, value in setting.iteritems():
retval[key] = callable(value) and value or get_callable(value)
else:
for value in setting:
value = callable(value) and value or get_callable(value)
retval[value.__name__] = value
return retval
def check(self):
if not THROTTLING_ENABLED:
return
if THROTTLING_IGNORE_ADMINS and self.request.user.is_superuser:
return
cache_key, timeout = self.get_cache_key()
if not cache_key:
return
if timeout is False: # view is disabled
return HttpResponseBadRequest()
if (timeout is None) or (timeout is 0):
return
if isinstance(timeout, basestring):
if timeout.startswith('/'):
return HttpResponseRedirect(timeout)
else:
callback = get_callable(timeout)
maintenance_bundle = {
'view_func': self.view_func,
'view_args': self.view_args,
'view_kwargs': self.view_kwargs
}
return callback(self.request, maintenance_bundle)
now = int(time.time() * 1000)
last_access = cache.get(cache_key, 0)
delta = now - last_access
if delta >= timeout:
cache.set(cache_key, now, THROTTLING_CACHE_EXPIRE)
return
congestion_view = self.view_throttling.get('congestion') or THROTTLING.get('congestion')
if congestion_view:
if congestion_view.startswith('/'):
return HttpResponseRedirect(congestion_view)
else:
callback = get_callable(congestion_view)
congestion_bundle = {
'view_func': self.view_func,
'view_args': self.view_args,
'view_kwargs': self.view_kwargs,
'timeout': timeout,
'delta': delta,
}
return callback(self.request, congestion_bundle)
return HttpResponseBadRequest()
def process(self, request):
page_url = self.parent.get_absolute_url()
# Get the rest of the URL
# Provide a way for appcontent items to customize URL processing by
# altering the perceived path of the page:
if "path_mapper" in self.app_config:
path_mapper = urlresolvers.get_callable(self.app_config["path_mapper"])
path, page_url = path_mapper(request.path, page_url, appcontent_parameters=self.parameters)
else:
path = request._feincms_extra_context["extra_path"]
# Resolve the module holding the application urls.
urlconf_path = self.app_config.get("urls", self.urlconf_path)
# Change the prefix and urlconf for the monkey-patched reverse function ...
_local.urlconf = (urlconf_path, page_url)
try:
fn, args, kwargs = resolve(path, urlconf_path)
except (ValueError, Resolver404):
del _local.urlconf
raise Resolver404
#: Variables from the ApplicationContent parameters are added to request
# so we can expose them to our templates via the appcontent_parameters
# context_processor
request._feincms_extra_context.update(self.parameters)
view_wrapper = self.app_config.get("view_wrapper", None)
if view_wrapper:
fn = partial(urlresolvers.get_callable(view_wrapper), view=fn, appcontent_parameters=self.parameters)
try:
output = fn(request, *args, **kwargs)
finally:
# We want exceptions to propagate, but we cannot allow the
# modifications to reverse() to stay here.
del _local.urlconf
if isinstance(output, HttpResponse):
if self.send_directly(request, output):
return output
elif output.status_code == 200:
self.rendered_result = mark_safe(output.content.decode("utf-8"))
self.rendered_headers = {}
# Copy relevant headers for later perusal
for h in ("Cache-Control", "Last-Modified", "Expires"):
if h in output:
self.rendered_headers.setdefault(h, []).append(output[h])
else:
self.rendered_result = mark_safe(output)
def _update(self, argv):
try:
get_callable(PRE_UPDATE_HOOK)()
except (AttributeError, ImportError):
pass
appcfg.main(argv[1:] + [PROJECT_DIR])
try:
get_callable(POST_UPDATE_HOOK)()
except (AttributeError, ImportError):
pass
def user_authorization(request, form_class=AuthorizeRequestTokenForm):
if 'oauth_token' not in request.REQUEST:
return HttpResponseBadRequest('No request token specified.')
oauth_request = get_oauth_request(request)
try:
request_token = store.get_request_token(request, oauth_request, request.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 }
else:
args = { 'error': _('Access not granted by user.') }
if request_token.callback is not None and request_token.callback != OUT_OF_BAND:
response = HttpResponseRedirect(request_token.get_callback_url(args))
else:
# try to get custom callback view
callback_view_str = getattr(settings, OAUTH_CALLBACK_VIEW,
'oauth_provider.views.fake_callback_view')
try:
callback_view = get_callable(callback_view_str)
except AttributeError:
raise Exception, "%s view doesn't exist." % callback_view_str
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:
authorize_view = get_callable(authorize_view_str)
except AttributeError:
raise Exception, "%s view doesn't exist." % authorize_view_str
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 from_setting(setting, values_must_be_callable=False):
retval = {}
setting = getattr(settings, setting, {})
if isinstance(setting, dict):
for key, value in setting.iteritems():
if values_must_be_callable and not callable(value):
value = get_callable(value)
retval[key] = value
else:
for value in setting:
if values_must_be_callable and not callable(value):
value = get_callable(value)
retval[value.__name__] = value
return retval
def auth_success_response(user):
from attribute_formatters import CAS, NSMAP, etree
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
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)
return unicode(etree.tostring(response, encoding='utf-8'), 'utf-8')
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:
view = get_callable(fallback)
if not callable(view):
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 __dispatch(request, *args, **kwargs):
handler = lc_methods.get(request.method.lower())
if handler:
handler = get_callable(handler)
return handler(request, *args, **kwargs)
else:
return HttpResponseNotAllowed(m.upper() for m in lc_methods.keys())
def get_resource_uri_index(self):
"""
INDEX URI template processor.
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
# else this url will be in get_resource_uri_template
if args or kwargs:
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver('maker.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if not params:
return _convert(result)
except:
return None
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
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('maker.core.api.urls').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
def _path(route, view, kwargs=None, name=None, Pattern=None):
if DJANGO_VERSION < (2, 0, 0, 'final', 0):
raise ImportError(
'cbvpatterns.path and cbvpatterns.re_path can only be call when using Django >= 2.0'
)
if isinstance(view, (list, tuple)):
# For include(...) processing.
pattern = Pattern(route, is_endpoint=False)
urlconf_module, app_name, namespace = view
return URLResolver(
pattern,
urlconf_module,
kwargs,
app_name=app_name,
namespace=namespace,
)
else:
if isinstance(view, six.string_types):
view = get_callable(view)
pattern = Pattern(route, name=name, is_endpoint=True)
return CBVURLPattern(pattern, view, kwargs, name)
else:
raise TypeError(
'view must be a callable or a list/tuple in the case of include().'
)
def auth_success_response(user, pgt, proxies):
etree.register_namespace('cas', CAS_URI)
response = etree.Element(CAS + 'serviceResponse')
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 unicode(etree.tostring(response, encoding='utf-8'), 'utf-8')
def callback(self):
if self._callback is not None:
return self._callback
callback = get_callable(self._callback_str)
self._callback = self.wrap_with_permissions(callback)
return self._callback
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 = urlresolvers.RegexURLResolver(r'^/', urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = urlresolvers.get_callable(url_or_view, True)
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 get_enabled_users(self, action):
if not callable(tcc_settings.ADMIN_CALLBACK):
return []
assert action in ['open', 'close', 'remove', 'restore',
'approve', 'disapprove']
func = get_callable(tcc_settings.ADMIN_CALLBACK)
return func(self, action)
def select_ui_plugin(request, slice_id):
slice = get_object_or_404(Slice, id=slice_id)
plugins_info = getattr(settings, "UI_PLUGINS", [])
logger.debug("select_ui_plugin plugins_info %s" % (plugins_info,))
# plugin functions should return (name, description, url)
plugins = [get_callable(plugin[0])(slice) for plugin in plugins_info]
logger.debug("select_ui_plugin plugins %s" % (plugins,) )
return simple.direct_to_template(
request,
template=TEMPLATE_PATH+"/select_ui_plugin.html",
extra_context={
"plugins": plugins, "slice": slice,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % slice.project.name, reverse("project_detail", args=[slice.project.id])),
("Slice %s" % slice.name, reverse("slice_detail", args=[slice_id])),
("Select UI", request.path),
),
},
)
def get_view(self):
self.type = self.get_type()
type_class = game_types.classes[self.type]
view = getattr(type_class, self.view_field)
view = get_callable(view)
return view
def get_resource_uri_index(self):
"""
INDEX URI template processor.
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
# else this url will be in get_resource_uri_template
if args or kwargs:
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(
'treeio.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if not params:
return _convert(result)
except:
return None
def merge_samples(from_sample, to_sample):
"""Copies all processes from one sample to another sample.
The fist sample will be erased afterwards.
:param from_sample: The sample, who is merged into the other sample
:param to_sample: The sample, who should contains the processes from the
other sample
:type from_sample: `samples.models.Sample`
:type to_sample: `samples.models.Sample`
"""
current_sample = to_sample
for process in from_sample.processes.order_by("-timestamp"):
if current_sample.split_origin and current_sample.split_origin.timestamp > process.timestamp:
current_sample = current_sample.split_origin.parent
current_sample.processes.add(process)
to_sample.series.add(*from_sample.series.all())
to_aliases = set(alias.name for alias in to_sample.aliases.all())
to_sample.aliases.add(*(alias for alias in from_sample.aliases.all() if alias.name not in to_aliases))
if not to_sample.aliases.filter(name=from_sample.name).exists():
to_sample.aliases.create(name=from_sample.name)
if settings.MERGE_CLEANUP_FUNCTION:
cleanup_after_merge = get_callable(settings.MERGE_CLEANUP_FUNCTION)
cleanup_after_merge(from_sample, to_sample)
from_sample.delete()
def process_incoming(self, request, sms):
"""
Process an incoming SMS message and call the correct hook.
"""
sms.save()
# work with uppercase and single spaces
content = sms.content.upper().strip()
content = re.sub('\s+', " ", content)
for keyword, subkeywords in hook.iteritems():
if content[:len(keyword)] == unicode(keyword):
subkeyword = content[len(keyword):].strip().split(
u' ')[0].strip()
if not subkeyword in subkeywords:
subkeyword = '*'
if subkeyword in subkeywords:
try:
callable_hook = get_callable(subkeywords[subkeyword])
except ImportError:
raise ImproperlyConfigured(
u'The function for %s was not found in the SMSGATEWAY_HOOK setting.'
% subkeywords[subkeyword])
else:
return callable_hook(request, sms)
return None
def _reverse_with_prefix(self, lookup_view, _prefix, *args, **kwargs):
if args and kwargs:
raise ValueError("Don't mix *args and **kwargs in call to " "reverse()!")
try:
lookup_view = urlresolvers.get_callable(lookup_view, True)
except (ImportError, AttributeError), e:
raise urlresolvers.NoReverseMatch("Error importing '%s': %s." % (lookup_view, e))
def _reverse_with_prefix(self, lookup_view, _prefix, *args, **kwargs):
if args and kwargs:
raise ValueError("Don't mix *args and **kwargs in call to reverse()!")
try:
lookup_view = get_callable(lookup_view, True)
except (ImportError, AttributeError), e:
raise NoReverseMatch("Error importing '%s': %s." % (lookup_view, e))
def process_incoming(self, request, sms):
"""
Process an incoming SMS message and call the correct hook.
:param Request request: the request we're handling. Passed to the handler
:param SMS sms: the sms we're processing
:returns: the result of the callable function, or None if nothing was called
"""
sms.save()
# work with uppercase and single spaces
content = sms.content.upper().strip()
content = sub('\s+', ' ', content)
# Try to find the correct hook
callable_name = self._find_callable(content, all_hooks)
# If no hook matched, check for a fallback
if not callable_name and hasattr(settings, 'SMSGATEWAY_FALLBACK_HOOK'):
callable_name = settings.SMSGATEWAY_FALLBACK_HOOK
if not callable_name:
return
callable_function = get_callable(callable_name)
return callable_function(request, sms)
def redirect_permissions_request(request, perm_name=None,
target_ct_id=None, target_id=None,
permittee_ct_id=None, permittee_id=None):
"""
Gets the target and permittee objects and passes them along with the
L{ExpedientPermission} object named by C{perm_name} to the view that's
used by the permission.
"""
permission = get_object_or_404(ExpedientPermission, name=perm_name)
target_obj_or_class = get_object_from_ids(target_ct_id, target_id)
# Change from ContentType to class
if type(target_obj_or_class) == ContentType:
target_obj_or_class = target_obj_or_class.model_class()
permittee = get_object_from_ids(permittee_ct_id, permittee_id)
if not permission.view:
raise PermissionDenied(perm_name, target_obj_or_class, permittee, False)
view = get_callable(permission.view)
logger.debug("Calling permission view %s" % permission.view)
# no urls allowed in redirection.
redirect_to = request.session.get("from_url", '')
if not redirect_to or ' ' in redirect_to or "//" in redirect_to:
redirect_to = None
return view(request, permission, permittee, target_obj_or_class,
redirect_to=redirect_to)
def merge_samples(from_sample, to_sample):
"""Copies all processes from one sample to another sample.
The fist sample will be erased afterwards.
:param from_sample: The sample, who is merged into the other sample
:param to_sample: The sample, who should contains the processes from the
other sample
:type from_sample: `samples.models.Sample`
:type to_sample: `samples.models.Sample`
"""
current_sample = to_sample
for process in from_sample.processes.order_by("-timestamp"):
if current_sample.split_origin and current_sample.split_origin.timestamp > process.timestamp:
current_sample = current_sample.split_origin.parent
current_sample.processes.add(process)
to_sample.series.add(*from_sample.series.all())
to_aliases = set(alias.name for alias in to_sample.aliases.all())
to_sample.aliases.add(*(alias for alias in from_sample.aliases.all() if alias.name not in to_aliases))
if not to_sample.aliases.filter(name=from_sample.name).exists():
to_sample.aliases.create(name=from_sample.name)
if settings.MERGE_CLEANUP_FUNCTION:
cleanup_after_merge = get_callable(settings.MERGE_CLEANUP_FUNCTION)
cleanup_after_merge(from_sample, to_sample)
from_sample.delete()
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
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(
'treeio.core.api.urls').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
def __init__(self, name, consumer_key=None, consumer_secret=None,
request_token_url=None, authorization_url=None,
access_token_url=None, realm=None, signature_method=None):
"""
Initialize an application instance based on the given configuration.
"""
self.name = name
self.consumer = {
'oauth_token': consumer_key,
'oauth_token_secret': consumer_secret,
}
self.request_token_url = request_token_url
self.authorization_url = authorization_url
self.access_token_url = access_token_url
self.realm = realm
# dynamic constants ;)
self.NEEDS_AUTH_VIEW_NAME = name + '_needs_auth'
self.SUCCESS_VIEW_NAME = name + '_success'
self.ACCESS_TOKEN_NAME = name + '_access_token'
self.REQUEST_TOKEN_NAME = name + '_request_token'
self.NEXT_URL_NAME = name + '_next_url'
# these are used to decide if the application will do a redirect or
# show a template with the respective views
self._has_needs_auth_template = True
self._has_success_auth_template = True
try:
self.sig_method = get_callable(signature_method or DEFAULT_SIGNATURE_METHOD)
except KeyError:
raise UnknownSignatureMethod()
def callback(self):
if self._callback is not None:
return self._callback
callback = get_callable(self._callback_str)
self._callback = self.wrap_with_permissions(callback)
return self._callback
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 = urlresolvers.RegexURLResolver(r"^/", urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = urlresolvers.get_callable(url_or_view, True)
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 return_urls(handler):
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return u'%s%s' % (get_script_prefix(), paths)
try:
resource_uri = 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)
urls = []
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
for possibility, pattern, empty in possibilities:
for result, params in possibility:
urls.append(_convert(result, params))
return urls
except:
return None
def get_cache_key(self):
if 'uri' in self.view_throttling:
if not self.request.path.startswith(self.view_throttling['uri']):
return None, None
timeouts = (
('view_method', self.view_throttling.get(self.method)),
('view', self.view_throttling.get('all')),
('site_method', THROTTLING.get(self.method)),
('site', THROTTLING.get('all')),
)
format_args = {
'prefix': THROTTLING_CACHE_PREFIX,
'view': self.view_name,
'uid': self.request.user.id,
'ip': ip(self.request),
'method': self.request.method
}
if hasattr(self.request, 'session') and self.request.session.session_key:
format_args['session'] = self.request.session.session_key
for pattern_key, timeout in timeouts:
if timeout is not None:
if isinstance(timeout, basestring) and timeout.startswith('callable:'):
callback_name = timeout.split('callable:')[1]
return get_callable(callback_name)(self.request, self.view_func, self.view_args, self.view_kwargs)
return THROTTLING_CACHE_KEY_PATTERNS[pattern_key] % format_args, timeout
return None, None
def packing_slip_pdf(pdf, order):
pdf.init_letter(page_fn=create_stationery_fn(get_callable(plata.settings.PLATA_REPORTING_STATIONERY)()))
if plata.settings.PLATA_REPORTING_ADDRESSLINE:
pdf.address_head(plata.settings.PLATA_REPORTING_ADDRESSLINE)
pdf.address(order.addresses()["shipping"])
pdf.next_frame()
pdf.p(
u"%s: %s"
% (
capfirst(_("order date")),
order.confirmed and order.confirmed.strftime("%d.%m.%Y") or _("Not confirmed yet"),
)
)
pdf.spacer(3 * mm)
pdf.h1(_("Order %09d") % order.id)
pdf.hr()
pdf.table(
[(_("SKU"), capfirst(_("product")), capfirst(_("quantity")))]
+ [(item.variation.sku, unicode(item.variation), item.quantity) for item in order.items.all()],
(2 * cm, 13.4 * cm, 1 * cm),
pdf.style.tableHead + (("ALIGN", (1, 0), (1, -1), "LEFT"),),
)
if order.notes:
pdf.spacer(10 * mm)
pdf.p(capfirst(_("notes")), style=pdf.style.bold)
pdf.spacer(1 * mm)
pdf.p(order.notes)
pdf.generate()
def select_ui_plugin(request, slice_id):
slice = get_object_or_404(Slice, id=slice_id)
plugins_info = getattr(settings, "UI_PLUGINS", [])
logger.debug("select_ui_plugin plugins_info %s" % (plugins_info, ))
# plugin functions should return (name, description, url)
plugins = [get_callable(plugin[0])(slice) for plugin in plugins_info]
logger.debug("select_ui_plugin plugins %s" % (plugins, ))
return simple.direct_to_template(
request,
template=TEMPLATE_PATH + "/select_ui_plugin.html",
extra_context={
"plugins":
plugins,
"slice":
slice,
"breadcrumbs": (
("Home", reverse("home")),
("Project %s" % slice.project.name,
reverse("project_detail", args=[slice.project.id])),
("Slice %s" % slice.name,
reverse("slice_detail", args=[slice_id])),
("Select UI", request.path),
),
},
)
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.'
print("FORM ERROR", form.errors)
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 get_enabled_users(self, action):
if not callable(ADMIN_CALLBACK):
return []
assert action in [
'open', 'close', 'remove', 'restore', 'approve', 'disapprove'
]
func = get_callable(ADMIN_CALLBACK)
return func(self, action)
def __init__(self, view, url, args, kwargs):
view = get_callable(view)
if (not is_crumbed(view)):
raise ValueError("The view is not crumbed")
self._view = view
self._url = url
# Theese are exactly those args expected by view, not by url pattern
self._args = args
self._kwargs = kwargs
def discover_view(view, prefix=''):
if isinstance(view, basestring):
if not view:
raise ValueError('View name is required to discover the callable')
if prefix:
view = prefix + '.' + view
return get_callable(view)
else:
return view
def get_payment_modules(self, request=None):
"""
Import and return all payment modules defined in ``PLATA_PAYMENT_MODULES``
If request is given only aplicable modules are loaded.
"""
all_modules = [get_callable(module)(self) for module in plata.settings.PLATA_PAYMENT_MODULES]
if not request:
return all_modules
return filter(lambda item: item.enabled_for_request(request), all_modules)
def get_bases(self):
"""
Get the base class from the dotted path, or return the base class if it
has already been determined.
"""
if self.base is not None:
return self.base
self.base = get_callable(self.base_str)
return self.base
def multipayment_forms(request, order_form):
processors = settings.SECONDARY_PAYMENT_PROCESSORS
forms = []
for dummy_key, processor in processors:
name = processor['name']
form_class_name = processor['form']
form_class = get_callable(form_class_name)
form = form_class(request, order_form)
forms.append((name, form))
return forms
def build_views(self):
"""
Bake out specified buildable views.
"""
# Then loop through and run them all
for view_str in self.view_list:
if self.verbosity > 1:
six.print_("Building %s" % view_str)
view = get_callable(view_str)
view().build_method()
def process_request(self, request):
for url_rule in url_management_registry:
path = request.get_full_path()
params = url_rule.parse_url(path)
if params:
callback, callback_args, callback_kwargs = params
if not callable(callback):
callback = get_callable(callback)
return callback(request, *callback_args, **callback_kwargs)
return None
def __getattr__(self, name):
if self._environment == None:
self._environment = Environment(extensions=global_exts,
loader=ChoiceLoader(loader_array))
self._environment.globals['STATIC_URL'] = settings.STATIC_URL
self._environment.globals['url_reverse'] = get_callable(
'django.core.urlresolvers.reverse_lazy')
if name == '__members__':
return dir(self._environment)
return getattr(self._environment, name)
def callback(self):
if self._callback_processed is not None:
return self._callback
if getattr(self, '_callback_str', None) is not None:
self._callback = get_callable(self._callback_str)
if isinstance(self._callback, type) and issubclass(self._callback, View):
self._callback = self._callback.as_view()
else:
self._callback = self._callback
self._callback_processed = True
return self._callback
def update(self, argv):
self.clean_upload()
try:
self.prepare_upload()
try:
get_callable(PRE_UPDATE_HOOK)()
except (AttributeError, ImportError):
pass
appcfg.main(argv[1:] + [PROJECT_DIR])
try:
get_callable(POST_UPDATE_HOOK)()
except (AttributeError, ImportError):
pass
finally:
self.clean_upload()
def __init__(self):
self.client = Campfire(settings.CAMPFIRE_SUBDOMAIN,
settings.CAMPFIRE_API_KEY,
ssl=True)
self.rooms = []
self.plugins = []
for p in settings.INSTALLED_PLUGINS:
klass = get_callable(p)
if klass:
print 'Loading plugin: %s' % klass
self.plugins.append(klass())
def build_views(self):
"""
Bake out specified buildable views.
"""
# Then loop through and run them all
for view_str in self.view_list:
logger.debug("Building %s" % view_str)
if self.verbosity > 1:
self.stdout.write("Building %s" % view_str)
view = get_callable(view_str)
self.get_view_instance(view).build_method()
def test_badge_getter(self):
q_getter = settings.MOZBADGES.get('badge_getter', '')
self.assertTrue(q_getter,
"settings.MOZBADGES['badge_getter'] must be set.")
self.assertIn(
'.', q_getter, "Invalid settings.MOZBADGES['badge_getter']. " +
"Expecting 'module.funcion'.")
method = get_callable(q_getter)
self.assertTrue(callable(method),
"%s not a callable object." % q_getter)
def _set_attr(self, prefix_name, value):
name = prefix_name[len(self.prefix) + 1:]
if name == 'CALLBACK':
if isinstance(value, six.string_types):
func = get_callable(value)
elif callable(value):
func = value
else:
raise ImproperlyConfigured("`CALLBACK` must be a callable or a fullpath to callable")
self._callback = func
setattr(self, name, value)
def signedStrFromUser(user):
"""
decode and verify signature of string
"""
dct = SharedAuthBackend.dictFromUser(user)
extra_params_provider = getattr(settings, 'EXTRA_PARAMS_PROVIDER', None)
if extra_params_provider:
extra_params_provider = get_callable(extra_params_provider)
dct['extra_params'] = extra_params_provider(user)
return signed.dumps(dct)
def jsonStrFromUser(user):
"""
encode a sign a string
"""
dct = SharedAuthBackend.dictFromUser(user)
extra_params_provider = getattr(settings, 'EXTRA_PARAMS_PROVIDER', None)
if extra_params_provider:
extra_params_provider = get_callable(extra_params_provider)
dct['extra_params'] = extra_params_provider(user)
return json.dumps(dct)
def __init__(self, regex, function):
try:
self.regex = re.compile(regex)
except re.error as e:
raise ImproperlyConfigured(
'"%s" is not a valid regular expression: %s' %
(regex, six.text_type(e)))
try:
self.callback = get_callable(function)
except ViewDoesNotExist:
raise ImproperlyConfigured(
'Bad Submission Time Validation: Could not import: %s' %
function)
