def callback(self):
if self._callback is not None:
return self._callback
elif self._callback_str is None:
return lambda *args, **kwargs: None
try:
self._callback = get_callable(self._callback_str)
except ImportError as e:
mod_name, _ = get_mod_func(self._callback_str)
raise ImproperlyConfigured("Could not import '%s'. " "Error was: %s" % (mod_name, str(e)))
except AttributeError as e:
mod_name, func_name = get_mod_func(self._callback_str)
raise ImproperlyConfigured("Tried '%s' in module '%s'. " "Error was: %s" % (func_name, mod_name, str(e)))
return self._callback
def get_callable(lookup_view, can_fail=False):
"""
Convert a string version of a function name to the callable object.
If the lookup_view is not an import path, it is assumed to be a URL pattern
label and the original string is returned.
If can_fail is True, lookup_view might be a URL pattern label, so errors
during the import fail and the string is returned.
"""
if not callable(lookup_view):
mod_name, func_name = get_mod_func(lookup_view)
try:
if func_name != "":
lookup_view = getattr(import_module(mod_name), func_name)
if not callable(lookup_view):
raise ImproperlyConfigured("Could not import %s.%s." % (mod_name, func_name))
except AttributeError:
if not can_fail:
raise ImproperlyConfigured(
"Could not import %s. Callable " "does not exist in module %s." % (lookup_view, mod_name)
)
except ImportError:
parentmod, submod = get_mod_func(mod_name)
if not can_fail and submod != "" and not module_has_submodule(import_module(parentmod), submod):
raise ImproperlyConfigured(
"Could not import %s. Parent " "module %s does not exist." % (lookup_view, mod_name)
)
if not can_fail:
raise
return lookup_view
def get_callable(lookup_view, can_fail=False):
"""
Convert a string version of a function name to the callable object.
If the lookup_view is not an import path, it is assumed to be a URL pattern
label and the original string is returned.
If can_fail is True, lookup_view might be a URL pattern label, so errors
during the import fail and the string is returned.
"""
if not callable(lookup_view):
mod_name, func_name = get_mod_func(lookup_view)
try:
if func_name != '':
lookup_view = getattr(import_module(mod_name), func_name)
if not callable(lookup_view):
raise ImproperlyConfigured("Could not import %s.%s." %
(mod_name, func_name))
except AttributeError:
if not can_fail:
raise ImproperlyConfigured("Could not import %s. Callable "
"does not exist in module %s." %
(lookup_view, mod_name))
except ImportError:
parentmod, submod = get_mod_func(mod_name)
if (not can_fail and submod != '' and not module_has_submodule(
import_module(parentmod), submod)):
raise ImproperlyConfigured("Could not import %s. Parent "
"module %s does not exist." %
(lookup_view, mod_name))
if not can_fail:
raise
return lookup_view
def get_connected():
if not settings.PAGE_CONNECTED_MODELS:
return []
models = []
for capp in settings.PAGE_CONNECTED_MODELS:
model = {}
mod_name, model_name = get_mod_func(capp['model'])
model['model_name'] = model_name
m = getattr(__import__(mod_name, {}, {}, ['']), model_name)
model['model'] = m
options = capp.get('options', {})
model['options'] = options
if 'form' in capp:
mod_name, form_name = get_mod_func(capp['form'])
f = getattr(__import__(mod_name, {}, {}, ['']), form_name)
model['options'].update({'form': f})
admin_class = admin.StackedInline
if 'admin' in capp:
mod_name, admin_class_name = get_mod_func(capp['admin'])
admin_class = getattr(__import__(mod_name, {}, {}, ['']),
admin_class_name)
models.append((admin_class, m, options))
return models
def get_connected():
if not settings.PAGE_CONNECTED_MODELS:
return []
models = []
for capp in settings.PAGE_CONNECTED_MODELS:
model = {}
mod_name, model_name = get_mod_func(capp['model'])
model['model_name'] = model_name
m = getattr(__import__(mod_name, {}, {}, ['']), model_name)
model['model'] = m
options = capp.get('options', {})
model['options'] = options
if 'form' in capp:
mod_name, form_name = get_mod_func(capp['form'])
f = getattr(__import__(mod_name, {}, {}, ['']), form_name)
model['options'].update({'form': f})
admin_class = admin.StackedInline
if 'admin' in capp:
mod_name, admin_class_name = get_mod_func(capp['admin'])
admin_class = getattr(__import__(mod_name, {}, {}, ['']), admin_class_name)
models.append((admin_class, m, options))
return models
def process_step(self, request, form, step):
super(ModeWizard, self).process_step(request, form, step)
form0 = self.get_form(0, request.POST)
if not form0.is_valid():
return self.render_revalidation_failure(request, 0, form0)
if not step:
paths = []
for i in range(self.num_conditions):
values = form.cleaned_data['condition_' +
str(i + 1)].split('|')
if not values[0]:
continue
condition_model, condition_field = get_mod_func(values[0])
condition_model = globals()[condition_model]
paths.append(
(i + 1, condition_model,
path_v1(self.base_model,
condition_model), condition_field, values[1]))
self.form_list[step + 1] = pathchoiceform_factory(
self.base_model, paths)
elif step == 2:
paths = []
for i in range(self.num_columns):
values = form.cleaned_data['column_' + str(i + 1)].split('|')
if not values[0]:
continue
field_model, field_field = get_mod_func(values[0])
field_model = globals()[field_model]
paths.append((i + 1, field_model,
path_v1(self.base_model,
field_model), field_field, values[1]))
self.form_list[step + 1] = pathchoiceform_factory(
self.base_model, paths)
def get_connected():
if not settings.PAGE_CONNECTED_MODELS:
return []
models = []
for capp in settings.PAGE_CONNECTED_MODELS:
model = {}
mod_name, model_name = get_mod_func(capp["model"])
model["model_name"] = model_name
m = getattr(__import__(mod_name, {}, {}, [""]), model_name)
model["model"] = m
options = capp.get("options", {})
model["options"] = options
if "form" in capp:
mod_name, form_name = get_mod_func(capp["form"])
f = getattr(__import__(mod_name, {}, {}, [""]), form_name)
model["options"].update({"form": f})
admin_class = admin.StackedInline
if "admin" in capp:
mod_name, admin_class_name = get_mod_func(capp["admin"])
admin_class = getattr(__import__(mod_name, {}, {}, [""]), admin_class_name)
models.append((admin_class, m, options))
return models
def __new__(cls, prefix=None):
obj = object.__new__(cls)
obj.pluggable_unique_identifier = '/@@pluggableapp@@/%s/' % str(uuid.uuid4())
obj.pluggable_prefix = prefix
view_prefix = cls.urlpatterns[0]
urlpatterns = []
for pattern_type, pattern_args, pattern_kwargs in copy.deepcopy(cls.urlpatterns[1:]):
if pattern_type == 'url':
view = pattern_args[1]
if type(view) == list:
raise Exception("Pluggable applications do not support 'include(...)' url definitions.")
# Handle a view directly
if callable(view):
pattern_args[1] = pluggable_view(view, obj)
# Handle a view_prefix combined with function name or a full view path
elif isinstance(view, (str, unicode)) and (view_prefix or '.' in view):
view_name = view_prefix and '%s.%s' % (view_prefix, view) or view
try:
pattern_args[1] = pluggable_view(get_callable(view), obj)
except ImportError, e:
mod_name, _ = get_mod_func(view)
raise ViewDoesNotExist("Could not import %s. Error was: %s" % (mod_name, str(e)))
except AttributeError, e:
mod_name, func_name = get_mod_func(view)
raise ViewDoesNotExist("Tried %s in module %s. Error was: %s" % (func_name, mod_name, str(e)))
# Handle class view.
elif isinstance(view, (str, unicode)) and hasattr(obj, view):
# Avoid reapplying pluggable view decorator when it has aready been applied. (i.e. the same function is reused in the same configuration.
if not getattr(getattr(obj, view), 'pluggable_unique_identifier', '') == obj.pluggable_unique_identifier:
setattr(obj, view, pluggable_class_view(getattr(obj, view), obj))
pattern_args[1] = getattr(obj, view)
def render(self, context):
view = self.view.resolve(context)
if not callable(view):
try:
view = get_callable(view)
except ImportError, e:
mod_name, _ = get_mod_func(view)
raise ViewDoesNotExist(
"Could not import %s. Error was: %s" % (mod_name, str(e)))
except AttributeError, e:
mod_name, func_name = get_mod_func(view)
raise ViewDoesNotExist("Tried %s in module %s. Error was: %s" %
(func_name, mod_name, str(e)))
def search(self, request, collection, filter_parameters, order_parameters):
parameters = ' | '.join(collection.parameters.split(',')).strip(' |')
objects = SearchQuerySet().filter(content=parameters)
if hasattr(settings, "COLLECTIONS_HAYSTACK_MODELS"):
haystack_models = settings.COLLECTIONS_HAYSTACK_MODELS
#if we're a string pull out the function
if isinstance(haystack_models, str):
mod_name, func_name = get_mod_func(haystack_models)
haystack_models = getattr(import_module(mod_name), func_name)
#if we're a function pull out the models
if callable(haystack_models):
haystack_models = haystack_models(request)
model_list = []
for haystack_model in haystack_models:
app_model = haystack_model.split('.')
model_list.append(get_model(*app_model))
objects.models(*model_list)
if isinstance(order_parameters, list):
objects = objects.order_by(*order_parameters)
if isinstance(filter_parameters, dict):
objects = objects.filter(**filter_parameters)
return objects
def view_detail(request, view):
if not utils.docutils_is_available:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(import_module(mod), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(
metadata[key],
'model', _('view:') + view
)
name = view.split('.')[-1].replace('_', '/')
param = {
'root_path': get_root_path(),
'name': name,
'summary': title,
'body': body,
'meta': metadata
}
return render_to_response(
'doc/view_detail.tpl',
param,
context_instance=RequestContext(request)
)
def validate_view_path_exists(self, lookup_view):
from django.core import urlresolvers
try:
lookup_view = lookup_view.encode('ascii')
mod_name, func_name = urlresolvers.get_mod_func(lookup_view)
lookup_view = getattr(urlresolvers.import_module(mod_name), func_name)
if not callable(lookup_view):
raise forms.ValidationError("'%s.%s' is not a callable." % (mod_name, func_name))
except ImportError as e:
mod_name, _ = urlresolvers.get_mod_func(lookup_view)
raise forms.ValidationError("Could not import %s. Error was: %s" % (mod_name, str(e)))
except AttributeError as e:
mod_name, func_name = urlresolvers.get_mod_func(lookup_view)
raise forms.ValidationError("Tried %s in module %s. Error was: %s" % (func_name, mod_name, str(e)))
except Exception as e:
raise forms.ValidationError("Invalid lookup_view %s. Error was: %s" % (lookup_view, str(e)))
def _get_admin_urlconf(self):
if not hasattr(self, "_admin_urlconf_module"):
try:
name = "%s.%s" % (get_mod_func(self.__class__.__module__)[0], "admin_urls")
self._admin_urlconf_module = __import__(name, {}, {}, [""])
except Exception, e:
raise ImproperlyConfigured, "Error while importing extension's admin URLconf %r: %s" % (name, e)
def callback(request):
enc_response = request.REQUEST["encResponse"]
if not enc_response:
raise d.Http404("No encResponse")
data = dec_response(request, enc_response)
if not data:
raise Http404("Checksum Failed")
order_id = request.session["dcavenue_order_id"]
if order_id:
del request.session["dcavenue_order_id"]
else:
raise Http404("No order id in session")
if order_id != data["Order_Id"]:
raise Http404("Invalid orderid")
cb_module, cb_method = get_mod_func(
settings.DCAVENUE.get("CALLBACK", "dcavenue.utils.default_callback"))
cb = getattr(__import__(cb_module, {}, {}, ['']), cb_method)
return cb(request, data)
def view_detail(request, view):
if not utils.docutils_is_available:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(__import__(mod, {}, {}, ['']), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model',
_('view:') + view)
return render_to_response('admin_doc/view_detail.html', {
'root_path': get_root_path(),
'name': view,
'summary': title,
'body': body,
'meta': metadata,
},
context_instance=RequestContext(request))
def verify_anon( request, forward_to, *arguments, **keywords):
"""
verify the captcha and then forward the request for anonymous users only
TBD: redirect to the original form with a validation error
"""
captcha_error = []
if request.POST and request.user.is_authenticated():
id = request.POST["captcha_id"]
word = request.POST["captcha_word"]
test = _getFactory(SITE_ID).get(id)
if not test:
captcha_error.append('Invalid captcha id.')
if not test.valid:
captcha_error.append('Test invalidated, try again.')
elif not test.testSolutions([word]):
captcha_error.append('Invalid word.')
mod_name, func_name = urlresolvers.get_mod_func(forward_to)
try:
func, ignore = getattr(__import__(mod_name, '', '', ['']), func_name), {}
return func( request, captcha_error, *arguments, **keywords)
except (ImportError, AttributeError), e:
raise ViewDoesNotExist, "Tried %s. Error was: %s" % (forward_to, str(e))
def _lookup_exclude(cls, name):
'''
Used to process each object named in BLUESTEM_EXCLUDE setting.
Attempts first to find as module ...
'''
# Try importing name as module.
try:
mod = import_module(name)
# If name doesn't import as module, we go on to determine whether
# name is instead a view reference.
except ImportError:
pass
# Raise exception if something else is amiss with import.
except ValueError:
raise ImproperlyConfigured \
('Error processing BLUESTEM_EXCLUDE. Is BLUESTEM_EXCLUDE '
'a correctly defined list or tuple?')
# Module import succeeded.
else:
# If urlpatterns attribute isn't present; name isn't a proper
# url module reference.
if not hasattr(mod, 'urlpatterns'):
raise ImproperlyConfigured \
('Module \'%s\' lacks a \'urlpatterns\' attribute' % \
mod.__name__)
# Return list of callback functions for every item in urlpatterns.
return [ u.callback for u in mod.urlpatterns if u.callback ]
# Since name didn't import as module, we now see whether it's
# a reference to a view function contained in a module.
mod_name, func_name = get_mod_func(name)
# Try importing containing module.
try:
mod = import_module(mod_name)
# Raise exception if module doesn't import.
except ImportError:
raise ImproperlyConfigured \
('Name \'%s\' is neither url module or view' % name)
# Determine if named function is an attribute in module.
try:
view_func = getattr(mod, func_name)
# Not found; raise an exception.
except AttributeError:
raise ImproperlyConfigured \
('Module \'%s\' does not define a \'%s\' view' % \
(mod_name, func_name))
# Return callback function for view. (Returned as list to be
# consistent with behavior when processing a name that's url module.)
return [ view_func ]
def callback(self):
if self._callback is not None:
return self._callback
elif self._callback_str is None:
return lambda *args, **kwargs: None
try:
self._callback = get_callable(self._callback_str)
except ImportError as exc:
mod_name, _ = get_mod_func(self._callback_str)
raise ImproperlyConfigured("Could not import '%s'. "
"Error was: %s" % (mod_name, str(exc)))
except AttributeError as exc:
mod_name, func_name = get_mod_func(self._callback_str)
raise ImproperlyConfigured("Tried importing '%s' from module "
"'%s' but failed. Error was: %s" %
(func_name, mod_name, str(exc)))
return self._callback
def __new__(cls, prefix=None):
obj = object.__new__(cls)
obj.pluggable_unique_identifier = '/@@pluggableapp@@/%s/' % str(
uuid.uuid4())
obj.pluggable_prefix = prefix
view_prefix = cls.urlpatterns[0]
urlpatterns = []
for pattern_type, pattern_args, pattern_kwargs in copy.deepcopy(
cls.urlpatterns[1:]):
if pattern_type == 'url':
view = pattern_args[1]
if type(view) == list:
raise Exception(
"Pluggable applications do not support 'include(...)' url definitions."
)
# Handle a view directly
if callable(view):
pattern_args[1] = pluggable_view(view, obj)
# Handle a view_prefix combined with function name or a full view path
elif isinstance(view, (str, unicode)) and (view_prefix
or '.' in view):
view_name = view_prefix and '%s.%s' % (view_prefix,
view) or view
try:
pattern_args[1] = pluggable_view(
get_callable(view), obj)
except ImportError, e:
mod_name, _ = get_mod_func(view)
raise ViewDoesNotExist(
"Could not import %s. Error was: %s" %
(mod_name, str(e)))
except AttributeError, e:
mod_name, func_name = get_mod_func(view)
raise ViewDoesNotExist(
"Tried %s in module %s. Error was: %s" %
(func_name, mod_name, str(e)))
# Handle class view.
elif isinstance(view, (str, unicode)) and hasattr(obj, view):
# Avoid reapplying pluggable view decorator when it has aready been applied. (i.e. the same function is reused in the same configuration.
if not getattr(getattr(
obj, view), 'pluggable_unique_identifier',
'') == obj.pluggable_unique_identifier:
setattr(obj, view,
pluggable_class_view(getattr(obj, view), obj))
pattern_args[1] = getattr(obj, view)
def _get_parameters_from_setting(self, var_name, request):
"Get the parameters from the function specified in the settings"
if hasattr(settings, var_name):
request_cleaner = getattr(settings, var_name)
if not callable(request_cleaner):
mod_name, func_name = get_mod_func(request_cleaner)
request_cleaner = getattr(import_module(mod_name), func_name)
return request_cleaner(request)
return None
def validate_generic(request,formclass):
mod_name, form_name = get_mod_func(formclass)
formclass = getattr(__import__(mod_name, {}, {}, ['']), form_name)
form = formclass(request.POST)
if(request.GET.has_key('field')):
errors = form.errors.get(request.GET['field'],[])
else:
errors = form.errors
return JsonResponse({'valid': not errors, 'errors': errors})
def admin_urlconf(self):
"""The module defining URLs for the extension's admin site."""
try:
name = '%s.%s' % (get_mod_func(self.__class__.__module__)[0],
'admin_urls')
return __import__(name, {}, {}, [''])
except Exception as e:
raise ImproperlyConfigured(
"Error while importing extension's admin URLconf %r: %s" %
(name, e))
def _get_admin_urlconf(self):
if not hasattr(self, "_admin_urlconf_module"):
try:
name = "%s.%s" % (get_mod_func(
self.__class__.__module__)[0], "admin_urls")
self._admin_urlconf_module = __import__(name, {}, {}, [''])
except Exception, e:
raise ImproperlyConfigured, \
"Error while importing extension's admin URLconf %r: %s" % \
(name, e)
def admin_urlconf(self):
"""The module defining URLs for the extension's admin site."""
try:
name = '%s.%s' % (get_mod_func(
self.__class__.__module__)[0], 'admin_urls')
return __import__(name, {}, {}, [''])
except Exception as e:
raise ImproperlyConfigured(
"Error while importing extension's admin URLconf %r: %s" %
(name, e))
def test_handler_500():
settings.DEBUG = False
mod_name, func_name = get_mod_func(handler500)
callback = getattr(import_module(mod_name), func_name), {}
response = callback[0](get_request_fixture())
content = response.content
assert isinstance(response, HttpResponseServerError)
assert '<h1>500</h1>' in content
def get_module_attribute(path):
"""
Convert a string version of a function name to the callable object.
"""
lookup_callable = None
mod_name, attr = get_mod_func(path)
mod = import_module(mod_name)
if attr != '':
lookup_callable = getattr(mod, attr)
return lookup_callable
def callback(self):
if self._callback is not None:
return self._callback
elif self._callback_str is None:
return lambda *args, **kwargs: None
try:
self._callback = get_callable(self._callback_str)
except ImportError, e:
mod_name, _ = get_mod_func(self._callback_str)
raise ImproperlyConfigured(
"Could not import '%s'. Error was: %s" % (mod_name, str(e)))
def get_view(lookup_view):
"""
Uses similar logic to django.urlresolvers.get_callable, but always raises
on failures and supports class based views.
"""
lookup_view = lookup_view.encode('ascii')
mod_name, func_or_class_name = get_mod_func(lookup_view)
assert func_or_class_name != ''
view = getattr(import_module(mod_name), func_or_class_name)
assert callable(view) or hasattr(view, 'as_view')
return view
def get_view(lookup_view):
"""
Uses similar logic to django.urlresolvers.get_callable, but always raises
on failures and supports class based views.
"""
lookup_view = lookup_view.encode('ascii')
mod_name, func_or_class_name = get_mod_func(lookup_view)
assert func_or_class_name != ''
view = getattr(import_module(mod_name), func_or_class_name)
assert callable(view) or hasattr(view, 'as_view')
return view
def validate_view_path_exists(self, lookup_view):
from django.core import urlresolvers
try:
lookup_view = lookup_view.encode('ascii')
mod_name, func_name = urlresolvers.get_mod_func(lookup_view)
lookup_view = getattr(urlresolvers.import_module(mod_name),
func_name)
if not callable(lookup_view):
raise forms.ValidationError("'%s.%s' is not a callable." %
(mod_name, func_name))
except ImportError as e:
mod_name, _ = urlresolvers.get_mod_func(lookup_view)
raise forms.ValidationError("Could not import %s. Error was: %s" %
(mod_name, str(e)))
except AttributeError as e:
mod_name, func_name = urlresolvers.get_mod_func(lookup_view)
raise forms.ValidationError(
"Tried %s in module %s. Error was: %s" %
(func_name, mod_name, str(e)))
except Exception as e:
raise forms.ValidationError(
"Invalid lookup_view %s. Error was: %s" %
(lookup_view, str(e)))
def from_dotted_path(fullpath):
"""
Returns the specified attribute of a module, specified by a string.
``from_dotted_path('a.b.c.d')`` is roughly equivalent to::
from a.b.c import d
except that ``d`` is returned and not entered into the current namespace.
"""
module_name, fn_name = get_mod_func(fullpath)
return getattr(importlib.import_module(module_name), fn_name)
def ajax_form_handler(
request, form_cls, require_login=True, allow_get=settings.DEBUG
):
if require_login and not request.user.is_authenticated():
raise Http404("login required")
if not allow_get and request.method != "POST":
raise Http404("only post allowed")
if isinstance(form_cls, basestring):
# can take form_cls of the form: "project.app.forms.FormName"
from django.core.urlresolvers import get_mod_func
mod_name, form_name = get_mod_func(form_cls)
form_cls = getattr(__import__(mod_name, {}, {}, ['']), form_name)
form = form_cls(request, request.REQUEST)
if form.is_valid():
return JSONResponse({ 'success': True, 'response': form.save() })
return JSONResponse({ 'success': False, 'errors': form.errors })
def get_context_data(self, **kwargs):
view = self.kwargs["view"]
urlconf = urlresolvers.get_urlconf()
if urlresolvers.get_resolver(urlconf)._is_callback(view):
mod, func = urlresolvers.get_mod_func(view)
view_func = getattr(import_module(mod), func)
else:
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, "view", _("view:") + view)
if body:
body = utils.parse_rst(body, "view", _("view:") + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], "model", _("view:") + view)
kwargs.update({"name": view, "summary": title, "body": body, "meta": metadata})
return super(ViewDetailView, self).get_context_data(**kwargs)
def handle_tiny_url(request, tiny_id):
tiny_url = get_object_or_404(TinyURL, tiny_id=tiny_id)
if tiny_url.action == "r":
return HttpResponseRedirect(tiny_url.data)
elif tiny_url.action == "m":
return tiny_url.content_object.render(request)
elif tiny_url.action == "v":
mod_name, view_name = get_mod_func(tiny_url.data)
view = getattr(__import__(mod_name, {}, {}, ['']), view_name)
return view(request, tiny_url.content_object)
elif tiny_url.action == "i":
return render_to_response(
"dtinyurl/inline.html", { 'tiny_url': tiny_url },
context_instance = RequestContext(request)
)
else:
raise AssertionError("bad action: %s" % tiny_url.action)
def ajax_validator(request, form_cls):
"""
Usage
-----
# in urls.py have something like this:
urlpatterns = patterns('',
# ... other patterns
(
r'^ajax/validate-registration-form/$', 'ajax_validator',
{ 'form_cls': 'myproject.accounts.forms.RegistrationForm' }
),
)
# sample javascript code to use the validator
$(function(){
$("#id_username, #id_password, #id_password2, #id_email").blur(function(){
var url = "/ajax/validate-registration-form/?field=" + this.name;
var field = this.name;
$.ajax({
url: url, data: $("#registration_form").serialize(),
type: "post", dataType: "json",
success: function (response){
if(response.valid)
{
$("#"+field+"_errors").html("Sounds good");
}
else
{
$("#"+field+"_errors").html(response.errors);
}
}
});
});
});
"""
mod_name, form_name = get_mod_func(form_cls)
form_cls = getattr(__import__(mod_name, {}, {}, ['']), form_name)
form = form_cls(request.POST)
if "field" in request.GET:
errors = form.errors.get(request.GET["field"])
if errors: errors = errors.as_text()
else:
errors = form.errors
return JSONResponse({ "errors": errors, "valid": not errors })
def tool(request, model_cls, form_cls, template, ctx=DEFAULT_CONTEXT, next="", **kwargs):
# Allow passing model_cls as a string.
if isinstance(model_cls, str):
mod_name, model_name = get_mod_func(model_cls)
model_cls = getattr(__import__(mod_name, {}, {}, ['']), model_name)
#TODO: Could allow this to be overridden easier?
class ToolForm(form_cls):
objs = forms.ModelMultipleChoiceField(model_cls._default_manager.all())
form = ToolForm(request.POST or None)
if form.is_valid():
form.save(request, **kwargs)
return HttpResponseRedirect(next)
ctx['form'] = form
return render_to_response(template, ctx , RequestContext(request))
def _get_clients(self):
"""
Return a list of (protocol-name, display-name, client-object) tuples
for all installed backlinks modules.
"""
if not self._clients:
self._clients = []
for name, display, client_name in settings.INSTALLED_MODULES:
try:
module_name, obj = get_mod_func(client_name)
mod = __import__(module_name)
client_module = sys.modules[module_name]
client = getattr(client_module, obj)
except (ImportError, AttributeError):
continue
if hasattr(client, 'autodiscover'):
self._clients.append((name, display, client))
return self._clients
def _get_clients(self):
"""
Return a list of (protocol-name, display-name, client-object) tuples
for all installed backlinks modules.
"""
if not self._clients:
self._clients = []
for name, display, client_name in settings.INSTALLED_MODULES:
try:
module_name, obj = get_mod_func(client_name)
mod = __import__(module_name)
client_module = sys.modules[module_name]
client = getattr(client_module, obj)
except (ImportError, AttributeError):
continue
if hasattr(client, 'autodiscover'):
self._clients.append((name, display, client))
return self._clients
def get_context_data(self, **kwargs):
view = self.kwargs['view']
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(import_module(mod), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
kwargs.update({
'name': view,
'summary': title,
'body': body,
'meta': metadata,
})
return super(ViewDetailView, self).get_context_data(**kwargs)
def view_detail(request, view):
if not utils.docutils_is_available:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(import_module(mod), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, "view", _("view:") + view)
if body:
body = utils.parse_rst(body, "view", _("view:") + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], "model", _("view:") + view)
name = view.split(".")[-1].replace("_", "/")
param = {"root_path": get_root_path(), "name": name, "summary": title, "body": body, "meta": metadata}
return render_to_response("doc/view_detail.tpl", param, context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
view = self.kwargs['view']
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(import_module(mod), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model',
_('view:') + view)
kwargs.update({
'name': view,
'summary': title,
'body': body,
'meta': metadata,
})
return super(ViewDetailView, self).get_context_data(**kwargs)
def view_detail(request, view):
if not utils.docutils_is_available:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(__import__(mod, {}, {}, ['']), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
return render_to_response('admin_doc/view_detail.html', {
'name': view,
'summary': title,
'body': body,
'meta': metadata,
}, context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
view = self.kwargs['view']
urlconf = urlresolvers.get_urlconf()
if urlresolvers.get_resolver(urlconf)._is_callback(view):
mod, func = urlresolvers.get_mod_func(view)
view_func = getattr(import_module(mod), func)
else:
raise Http404
title, body, metadata = utils.parse_docstring(view_func.__doc__)
if title:
title = utils.parse_rst(title, 'view', _('view:') + view)
if body:
body = utils.parse_rst(body, 'view', _('view:') + view)
for key in metadata:
metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
kwargs.update({
'name': view,
'summary': title,
'body': body,
'meta': metadata,
})
return super(ViewDetailView, self).get_context_data(**kwargs)
def render(self, rerender):
# Add some classes to the block to help style it
block_classes = self.css_classes()
block_class = self.content_block.content_type.model_class()
render_function = block_class.render_function
mod_name, func_name = get_mod_func(render_function)
block_view = getattr(import_module(mod_name), func_name)
if self.block:
# Following https://github.com/blancltd/django-glitter/pull/15, now when adding a
# `GlitterBlock` to a page, `self.block` will not be set until the GlitterBlock has
# been saved on the front end.
#
# There's Block Views around, e.g. `glitter.blocks.form.views.form_view`, which
# presume `self.block` will be set and then error out.
#
# Ideally we'd change all the custom view functions to be less error prone, but
# this is the more defensive approach.
self.html = block_view(
self.block, self.glitter_page.request, rerender, self.content_block, block_classes
)
def _convert_data(report,result,column_list):
"""
Apply unicode conversion and data filters to the data in
result, and return the converted data.
"""
data_filter_func = None
if report.data_filter:
mod_name, func_name = get_mod_func(report.data_filter)
data_filter_func = getattr(__import__(mod_name, '', '', ['']), func_name)
display_data=[]
for row in result:
display_data_row = []
i = 0
for data in row:
if data_filter_func:
data = data_filter_func(column_list[i], data)
if report.data_source.data_encoding == '8859':
data = unicode(str(data), "iso-8859-1")
display_data_row.append(data)
i = i + 1
display_data.append(display_data_row)
return display_data
def form_handler(
request, form_cls, require_login=False, block_get=False, json=False,
next=None, template=None, login_url=None, success_template=None,
validate_only=False, form_renderer=None, **kwargs
):
next = next or (request.REQUEST.get("next"))
json = json or (request.REQUEST.get("json") == "true")
validate_only = validate_only or (request.REQUEST.get("validate_only") == "true")
login_url = login_url or request.REQUEST.get("login_url") or getattr(settings, "LOGIN_URL", "/accounts/login/")
if isinstance(form_cls, basestring):
# can take form_cls of the form: "project.app.forms.FormName"
mod_name, form_name = get_mod_func(form_cls)
form_cls = getattr(__import__(mod_name, {}, {}, ['']), form_name)
# Check Logged in status
if require_login:
logged_in = False
if callable(require_login):
logged_in = require_login(request)
else:
logged_in = request.user.is_authenticated()
if not logged_in:
redirect_url = "%s?next=%s" % (login_url, urllib2.quote(request.get_full_path()))
if json:
return JSONResponse({ 'success': False, 'redirect': redirect_url })
else:
return HttpResponseRedirect(redirect_url)
#Check block get
if block_get and request.method != "POST":
raise Http404("Only Post Allowed")
# render for a GET request
if request.method == "GET":
form = get_form(form_cls, request, with_data=False, **kwargs)
if template:
if form.__metaclass__ == forms.models.ModelFormMetaclass and form.instance:
form.initial = forms.model_to_dict(form.instance, form._meta.fields, form._meta.exclude)
if json:
rendered_form = render_to_string(
template, {'form':form}, context_instance=RequestContext(request)
)
return JSONResponse({'form':rendered_form}) #show we send back the kwargs also?
else:
return render_to_response(
template, {"form": form}, context_instance=RequestContext(request)
)
#if template is not present, it has to be a json call
else:
if form_renderer:
rendered_form = getattr(form, form_renderer)() # form.as_table, form.as_ul etc.
return JSONResponse({'form':rendered_form}) #show we send back the kwargs also?
else:
return JSONResponse(get_form_representation(form))
#with request method as POST
form = get_form(form_cls, request, with_data=True, **kwargs)
#Form validation
if form.is_valid():
if validate_only: # return if its only for validation, validate only assumes json=True
return JSONResponse({"valid": True, "errors": {}})
resp = form.save()
if json:
#The form must return a json serializable dictionary
return JSONResponse({
'success': True,
'response': resp
})
else:
if next: return HttpResponseRedirect(next)
if isinstance(resp, HttpResponse): return resp
if success_template or template:
#get success_template to render after successfull save or use the request GET template
template_to_render = success_template or template
return render_to_response(
template_to_render, {"form": form, 'saved' : resp}, context_instance=RequestContext(request)
)
else:
errors = form.errors
if validate_only:
return JSONResponse({ "errors": errors, "valid": False})
else:
if json:
return JSONResponse({ 'success': False, 'errors': form.errors })
if template:
return render_to_response(
template, {"form": form}, context_instance=RequestContext(request)
)
# DDF_DEFAULT_DATA_FIXTURE default = 'sequential'
# It must be 'sequential', 'static_sequential', 'global_sequential', 'random' or 'path.to.CustomDataFixtureClass'
try:
INTERNAL_DATA_FIXTURES = {
'sequential': SequentialDataFixture(),
'static_sequential': StaticSequentialDataFixture(),
'global_sequential': GlobalSequentialDataFixture(),
'random': RandomDataFixture()
}
if hasattr(settings, 'DDF_DEFAULT_DATA_FIXTURE'):
if settings.DDF_DEFAULT_DATA_FIXTURE in INTERNAL_DATA_FIXTURES.keys():
DDF_DEFAULT_DATA_FIXTURE = INTERNAL_DATA_FIXTURES[
settings.DDF_DEFAULT_DATA_FIXTURE]
else:
# path.to.CustomDataFixtureClass
mod_name, obj_name = get_mod_func(
settings.DDF_DEFAULT_DATA_FIXTURE)
module = import_module(mod_name)
custom_data_fixture = getattr(module, obj_name)
DDF_DEFAULT_DATA_FIXTURE = custom_data_fixture()
else:
DDF_DEFAULT_DATA_FIXTURE = INTERNAL_DATA_FIXTURES['sequential']
except:
six.reraise(
DDFImproperlyConfigured,
DDFImproperlyConfigured(
"DDF_DEFAULT_DATA_FIXTURE (%s) must be 'sequential', 'static_sequential', 'global_sequential', 'random' or 'path.to.CustomDataFixtureClass'."
% settings.DDF_DEFAULT_DATA_FIXTURE),
sys.exc_info()[2])
# DDF_IGNORE_FIELDS default = []
try:
False)
RESTRICT_OOTB_AUTH = getattr(settings, 'RPC4DJANGO_RESTRICT_OOTB_AUTH', True)
JSON_ENCODER = getattr(settings, 'RPC4DJANGO_JSON_ENCODER',
'django.core.serializers.json.DjangoJSONEncoder')
try:
# Python2
basestring
except NameError:
# Python3
basestring = str
# resolve JSON_ENCODER to class if it's a string
if isinstance(JSON_ENCODER, basestring):
mod_name, cls_name = get_mod_func(JSON_ENCODER)
json_encoder = getattr(import_module(mod_name), cls_name)
else:
json_encoder = JSON_ENCODER
# instantiate the rpcdispatcher -- this examines the INSTALLED_APPS
# for any @rpcmethod decorators and adds them to the callable methods
dispatcher = RPCDispatcher(RESTRICT_INTROSPECTION, RESTRICT_OOTB_AUTH,
json_encoder)
def rpcmethod(**kwargs):
'''
Accepts keyword based arguments that describe the method's rpc aspects
**Parameters**
def done(self, request, form_list):
args = []
for i in range(self.num_conditions):
values = form_list[0].cleaned_data['condition_' +
str(i + 1)].split(u'|')
if not values[0]:
continue
condition_model, condition_field = get_mod_func(values[0])
condition_model = globals()[condition_model]
query_term = values[1]
text = values[2]
val = condition_model._meta.init_name_map(
)[condition_field][0].to_python(text)
args.append(
(condition_model, str(condition_field), str(query_term), val))
condition_paths = defaultdict(list)
headers = []
for field_name, paths in form_list[1].cleaned_data.iteritems():
condition_model = globals()[get_mod_func(
field_name.partition('|')[2])[0]]
for path in paths:
condition_paths[condition_model].append(
path.rpartition(LOOKUP_SEP)[0])
headers = defaultdict(list)
view_paths = []
counts = {}
for field_name, paths in form_list[3].cleaned_data.iteritems():
I = int(field_name.partition('|')[0])
for path in paths:
if 'Count' in path:
path
actual_path = path.rpartition(LOOKUP_SEP)[0]
path = path.replace(LOOKUP_SEP, u'_')
counts[path] = Count(actual_path, distinct=True)
view_paths.append(path)
headers[I].append(path)
if not ('pk' in view_paths or 'id' in view_paths):
headers[0].append('pk')
headers = [[
path, form_list[2].cleaned_data['column_' + str(I)].split(u'|')[1]
if I else self.base_model.__name__ + u' Primary Key ID#'
] for I in range(self.num_columns + 1) for path in headers[I]]
queryset = path_v5(self.base_model, condition_paths,
*args).annotate(**counts)
fields = [header[0] for header in headers]
data = {}
for field in fields:
data[field] = list(queryset.values_list('pk', field))
pks = queryset.values_list('pk', flat=True)
for pk in pks:
data[pk] = defaultdict(list)
for field in fields:
for (pk, datum) in data[field]:
data[pk][field].append(datum)
from tempfile import TemporaryFile
from xlwt import Workbook
book = Workbook()
sheet1 = book.add_sheet('Sheet 1')
field_locations = {}
for j, header in enumerate(headers):
sheet1.write(0, j, header[1])
field_locations[header[0]] = j
for i, pk in enumerate(pks):
for field in fields:
sheet1.write(i + 1, field_locations[field],
', '.join(map(str, data[pk][field])))
response = HttpResponse(mimetype="application/ms-excel")
response[
'Content-Disposition'] = 'attachment; filename=%s' % 'DataViews.xls'
book.save(response)
return response
def _form_handler(request,
form_cls,
require_login=False,
block_get=False,
ajax=False,
next=None,
template=None,
login_url=None,
pass_request=True,
validate_only=False,
**kwargs):
"""
Some ajax heavy apps require a lot of views that are merely a wrapper
around the form. This generic view can be used for them.
"""
if "next" in request.REQUEST: next = request.REQUEST["next"]
from django.shortcuts import render_to_response
is_ajax = request.is_ajax() or ajax or request.REQUEST.get(
"json") == "true"
if isinstance(form_cls, basestring):
# can take form_cls of the form: "project.app.forms.FormName"
mod_name, form_name = get_mod_func(form_cls)
form_cls = getattr(__import__(mod_name, {}, {}, ['']), form_name)
validate_only = (validate_only
or request.REQUEST.get("validate_only") == "true")
if login_url is None:
login_url = getattr(settings, "LOGIN_URL", "/login/")
if callable(require_login):
require_login = require_login(request)
elif require_login:
require_login = not request.user.is_authenticated()
if require_login:
redirect_url = "%s?next=%s" % (
login_url, urlquote(request.get_full_path())) # FIXME
if is_ajax:
return JSONResponse({'success': False, 'redirect': redirect_url})
return HttpResponseRedirect(redirect_url)
if block_get and request.method != "POST":
raise Http404("only post allowed")
if next: assert template, "template required when next provided"
def get_form(with_data=False):
form = form_cls(request) if pass_request else form_cls()
form.next = next
if with_data:
form.data = request.REQUEST
form.files = request.FILES
form.is_bound = True
if hasattr(form, "init"):
res = form.init(**kwargs)
if res: raise ResponseReady(res)
return form
if is_ajax and request.method == "GET":
return JSONResponse(get_form_representation(get_form()))
if template and request.method == "GET":
return render_to_response(template, {"form": get_form()},
context_instance=RequestContext(request))
form = get_form(with_data=True)
if form.is_valid():
if validate_only:
return JSONResponse({"valid": True, "errors": {}})
r = form.save()
if is_ajax:
return JSONResponse({
'success':
True,
'response':
(form.get_json(r) if hasattr(form, "get_json") else r)
})
if isinstance(r, HttpResponse): return r
if next: return HttpResponseRedirect(next)
if template: return HttpResponseRedirect(r)
return JSONResponse({
'success':
True,
'response': (form.get_json(r) if hasattr(form, "get_json") else r)
})
if validate_only:
if "field" in request.REQUEST:
errors = form.errors.get(request.REQUEST["field"], "")
if errors: errors = "".join(errors)
else:
errors = form.errors
return JSONResponse({"errors": errors, "valid": not errors})
if is_ajax:
return JSONResponse({'success': False, 'errors': form.errors})
if template:
return render_to_response(template, {"form": form},
context_instance=RequestContext(request))
return JSONResponse({'success': False, 'errors': form.errors})
Decimal(amount) / Decimal(bitcoinprice_eur()['24h']))
def getNewBitcoinPayment_eur(amount):
return new_bitcoin_payment_eur(amount)
# initialize the conversion module
from django_bitcoin import currency
from django.core import urlresolvers
from django.utils import importlib
for dottedpath in settings.BITCOIN_CURRENCIES:
mod, func = urlresolvers.get_mod_func(dottedpath)
klass = getattr(importlib.import_module(mod), func)
currency.exchange.register_currency(klass())
# Historical prie storage
class HistoricalPrice(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
price = models.DecimalField(max_digits=16, decimal_places=2)
params = models.CharField(max_length=50)
currency = models.CharField(max_length=10)
class Meta:
verbose_name = _('HistoricalPrice')
verbose_name_plural = _('HistoricalPrices')
from django.conf import settings
from django.core.urlresolvers import get_mod_func
REGISTRY = {}
backends = getattr(settings, 'SMSGATEWAY_BACKENDS', ())
for entry in backends:
module_name, class_name = get_mod_func(entry)
backend_class = getattr(__import__(module_name, {}, {}, ['']), class_name)
instance = backend_class()
REGISTRY[instance.get_slug()] = instance
def get_backend(slug):
return REGISTRY.get(slug, None)
