def get_verbose_name(self):
"""
Returns the verbose name of the document.
Checks the original meta dict first. If it is not found
then generates a verbose name from from the object name.
"""
try:
return capfirst(get_verbose_name(self._meta['verbose_name']))
except KeyError:
return capfirst(get_verbose_name(self.object_name))
def get_verbose_name(self):
"""
Returns the verbose name of the document.
Checks the original meta dict first. If it is not found
then generates a verbose name from from the object name.
"""
try:
return capfirst(get_verbose_name(self._meta['verbose_name']))
except KeyError:
return capfirst(get_verbose_name(self.object_name))
def verbose_name(self):
"""
Returns the verbose name of the document.
Checks the original meta dict first. If it is not found
then generates a verbose name from from the object name.
"""
if self._verbose_name is None:
try:
self._verbose_name = capfirst(get_verbose_name(self._meta["verbose_name"]))
except KeyError:
self._verbose_name = capfirst(get_verbose_name(self.object_name))
return self._verbose_name
def __init__(self,
name,
func_get_value_from_object=None,
abstract=None,
doc=None,
analyzer=None):
self.name = name
self.verbose_name = get_verbose_name(self.name)
self.store = self.store
self.tokenize = self.tokenize
if self.abstract is not None:
self.abstract = abstract
else:
self.abstract = self.abstract
self.doc = doc
self.initialize()
if func_get_value_from_object:
self.func_get_value_from_object = func_get_value_from_object
# set analyzer
if analyzer and constant.ANALYZERS.has_key(analyzer):
self.analyzer = constant.ANALYZERS.get(analyzer)()
def contribute_to_class(self, cls, name):
from django.db.backends.util import truncate_name
cls._meta = self
self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS
# First, construct the default values for these options.
self.object_name = cls.__name__
self.module_name = self.object_name.lower()
self.verbose_name = get_verbose_name(self.object_name)
# Next, apply any overridden values from 'class Meta'.
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
# Ignore any private attributes that Django doesn't care about.
# NOTE: We can't modify a dictionary's contents while looping
# over it, so we loop over the *original* dictionary instead.
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
# verbose_name_plural is a special case because it uses a 's'
# by default.
setattr(self, 'verbose_name_plural', meta_attrs.pop('verbose_name_plural', string_concat(self.verbose_name, 's')))
# Any leftover attributes must be invalid.
if meta_attrs != {}:
raise TypeError("'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()))
else:
self.verbose_name_plural = string_concat(self.verbose_name, 's')
del self.meta
def healthcheck(func_or_name):
"""
Health check decorator.
Usage:
@healthcheck("My Check")
def my_check():
if something_is_not_okay():
raise ServiceReturnedUnexpectedResult()
@healthcheck
def other_check():
if something_is_not_available():
raise ServiceUnavailable()
"""
def inner(func):
cls = type(func.__name__, (BaseHealthCheck,), {'_wrapped': staticmethod(func)})
cls.identifier = name
plugin_dir.register(cls)
return func
if callable(func_or_name):
name = get_verbose_name(func_or_name.__name__).replace('_', ' ')
return inner(func_or_name)
else:
name = func_or_name
return inner
def reverse_translate_query(query):
new_query_string = u''
for i in query.lists():
# modelname=i[0]
modelstring = get_verbose_name(i[0])
value = i[1]
if modelstring in fixed_fields:
new_query_string += "&" + modelstring + "=" + value[0]
elif modelstring[0:7] == 'incluir':
new_query_string += "&" + modelstring
else:
modelname = ' '.join(modelstring.split()[1:])
appname = modelstring.split()[0]
ctype_list = ContentType.objects.filter(app_label=appname,
name=modelname)
if len(ctype_list) > 0:
ctype = ctype_list[0]
model_class = ctype.model_class()
for b in value:
d = model_class.objects.filter(pk=b)
if len(d) > 0:
new_query_string += "&" + modelstring + "=" + d[
0].nombre
new_query_string = new_query_string.lstrip("&")
return new_query_string
def view(request):
name = get_verbose_name(type(self).__name__).replace(' ','_')
context = {
'form': self.form,
}
template = getattr(self, 'search_template', 'search/search_%s.html' % name)
return TemplateResponse(request, template, context)
def contribute_to_class(self, cls, name):
cls._meta = self
self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS
# First, construct the default values for these options.
self.object_name = cls.__name__
self.module_name = self.object_name.lower()
self.verbose_name = get_verbose_name(self.object_name)
# Next, apply any overridden values from 'class Meta'.
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
# Ignore any private attributes that Django doesn't care about.
# NOTE: We can't modify a dictionary's contents while looping
# over it, so we loop over the *original* dictionary instead.
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
# verbose_name_plural is a special case because it uses a 's'
# by default.
setattr(self, 'verbose_name_plural', meta_attrs.pop('verbose_name_plural', string_concat(self.verbose_name, 's')))
# Any leftover attributes must be invalid.
if meta_attrs != {}:
raise TypeError("'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()))
else:
self.verbose_name_plural = string_concat(self.verbose_name, 's')
del self.meta
def view(request):
results =[]
query = None
formclass = self.category_search_form()
if request.GET:
# this uses GET, not POST. so the way to realize if data
# is being posted and we need a form bound, instead of
# needing an empty unbound form, is checking request.GET
form = formclass(request.GET)
self._set_choices(form)
if form.is_valid():
category_list = self.category_instances
if 'category' in form.cleaned_data:
category_index = form.cleaned_data['category']
if category_index != '':
category_list = [self.category_instances[category_index]]
for c in category_list:
results.append((c, c.get_results(form.cleaned_data, request)))
query = form.cleaned_data
else:
form = formclass()
self._set_choices(form)
context = {
'form': form,
'results': results,
'query_data': query
}
name = get_verbose_name(type(self).__name__).replace(' ','_')
template = getattr(self, 'search_template', 'search/results_%s.html' % name)
return TemplateResponse(request, template, context)
def healthcheck(func_or_name):
"""
Usage:
@healthcheck("My Check")
def my_check():
if something_is_not_okay():
raise ServiceReturnedUnexpectedResult()
@healthcheck
def other_check():
if something_is_not_available():
raise ServiceUnavailable()
"""
def inner(func):
cls = type(func.__name__, (BaseHealthCheck, ),
{'_wrapped': staticmethod(func)})
cls.identifier = name
plugin_dir.register(cls)
return func
if callable(func_or_name):
name = get_verbose_name(func_or_name.__name__).replace('_', ' ')
return inner(func_or_name)
else:
name = func_or_name
return inner
def __new__(cls, name, bases, attrs):
super_new = super(CMSPluginBaseMetaclass, cls).__new__
parents = [base for base in bases if isinstance(base, CMSPluginBaseMetaclass)]
if not parents:
# If this is CMSPluginBase itself, and not a subclass, don't do anything
return super_new(cls, name, bases, attrs)
new_plugin = super_new(cls, name, bases, attrs)
# validate model is actually a CMSPlugin subclass.
if not issubclass(new_plugin.model, CMSPlugin):
raise SubClassNeededError(
"The 'model' attribute on CMSPluginBase subclasses must be "
"either CMSPlugin or a subclass of CMSPlugin. %r on %r is not."
% (new_plugin.model, new_plugin)
)
# validate the template:
if not hasattr(new_plugin, 'render_template'):
raise ImproperlyConfigured(
"CMSPluginBase subclasses must have a render_template attribute"
)
# Set the default form
if not new_plugin.form:
form_meta_attrs = {
'model': new_plugin.model,
'exclude': ('position', 'placeholder', 'language', 'plugin_type')
}
form_attrs = {
'Meta': type('Meta', (object,), form_meta_attrs)
}
new_plugin.form = type('%sForm' % name, (ModelForm,), form_attrs)
# Set the default fieldsets
if not new_plugin.fieldsets:
basic_fields = []
advanced_fields = []
for f in new_plugin.model._meta.fields:
if not f.auto_created and f.editable:
if hasattr(f,'advanced'):
advanced_fields.append(f.name)
else: basic_fields.append(f.name)
if advanced_fields:
new_plugin.fieldsets = [
(
None,
{
'fields': basic_fields
}
),
(
_('Advanced options'),
{
'fields' : advanced_fields,
'classes' : ('collapse',)
}
)
]
# Set default name
if not new_plugin.name:
new_plugin.name = get_verbose_name(new_plugin.__name__)
return new_plugin
def __new__(cls, name, bases, attrs):
super_new = super(CMSPluginBaseMetaclass, cls).__new__
parents = [base for base in bases if isinstance(base, CMSPluginBaseMetaclass)]
if not parents:
# If this is CMSPluginBase itself, and not a subclass, don't do anything
return super_new(cls, name, bases, attrs)
new_plugin = super_new(cls, name, bases, attrs)
# validate model is actually a CMSPlugin subclass.
if not issubclass(new_plugin.model, CMSPlugin):
raise SubClassNeededError(
"The 'model' attribute on CMSPluginBase subclasses must be "
"either 'None' or a subclass of CMSPlugin. %r on %r is not."
% (new_plugin.model, new_plugin)
)
# validate the template:
if not hasattr(new_plugin, 'render_template'):
raise ImproperlyConfigured(
"CMSPluginBase subclasses must have a render_template attribute"
)
# Set the default form
if not new_plugin.form:
form_meta_attrs = {
'model': new_plugin.model,
'exclude': ('position', 'placeholder', 'language', 'plugin_type')
}
form_attrs = {
'Meta': type('Meta', (object,), form_meta_attrs)
}
new_plugin.form = type('%sForm' % name, (ModelForm,), form_attrs)
# Set the default fieldsets
if not new_plugin.fieldsets:
basic_fields = []
advanced_fields = []
for f in new_plugin.model._meta.fields:
if not f.auto_created and f.editable:
if hasattr(f,'advanced'):
advanced_fields.append(f.name)
else: basic_fields.append(f.name)
if advanced_fields:
new_plugin.fieldsets = [
(
None,
{
'fields': basic_fields
}
),
(
_('Advanced options'),
{
'fields' : advanced_fields,
'classes' : ('collapse',)
}
)
]
# Set default name
if not new_plugin.name:
new_plugin.name = get_verbose_name(new_plugin.__name__)
return new_plugin
def view(request):
if request.GET:
# We're being asked for results, actually
return self.results_view(request)
form = self.search_form()()
context = {
'form': form,
}
name = get_verbose_name(type(self).__name__).replace(' ','_')
template = getattr(self, 'search_template', 'search/search_%s.html' % name)
return TemplateResponse(request, template, context)
def contribute_to_class(self, cls, name):
from django.db import connection
from django.db.backends.util import truncate_name
cls._meta = self
self.installed = re.sub('\.models$', '',
cls.__module__) in settings.INSTALLED_APPS
# First, construct the default values for these options.
self.object_name = cls.__name__
self.module_name = self.object_name.lower()
self.verbose_name = get_verbose_name(self.object_name)
# Next, apply any overridden values from 'class Meta'.
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
# Ignore any private attributes that Django doesn't care about.
# NOTE: We can't modify a dictionary's contents while looping
# over it, so we loop over the *original* dictionary instead.
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
# unique_together can be either a tuple of tuples, or a single
# tuple of two strings. Normalize it to a tuple of tuples, so that
# calling code can uniformly expect that.
ut = meta_attrs.pop('unique_together', self.unique_together)
if ut and not isinstance(ut[0], (tuple, list)):
ut = (ut, )
self.unique_together = ut
# verbose_name_plural is a special case because it uses a 's'
# by default.
if self.verbose_name_plural is None:
self.verbose_name_plural = string_concat(
self.verbose_name, 's')
# Any leftover attributes must be invalid.
if meta_attrs != {}:
raise TypeError("'class Meta' got invalid attribute(s): %s" %
','.join(meta_attrs.keys()))
else:
self.verbose_name_plural = string_concat(self.verbose_name, 's')
del self.meta
# If the db_table wasn't provided, use the app_label + module_name.
if not self.db_table:
self.db_table = "%s_%s" % (self.app_label, self.module_name)
self.db_table = truncate_name(self.db_table,
connection.ops.max_name_length())
def __init__(self, field_name=None, label=None, public=None):
if field_name is not None:
self.field_name = field_name
if label is not None:
self.label = label
if self.label is None:
self.label = get_verbose_name(self.field_name)
if public is not None:
self.public = public
def __init__(self, field_name=None, label=None, public=None):
if field_name is not None:
self.field_name = field_name
if label is not None:
self.label = label
if self.label is None:
self.label = get_verbose_name(self.field_name)
if public is not None:
self.public = public
def contribute_to_class(self, cls, name):
from django.db import connection
from django.db.backends.util import truncate_name
cls._meta = self
self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS
# First, construct the default values for these options.
self.object_name = cls.__name__
self.module_name = self.object_name.lower()
self.verbose_name = get_verbose_name(self.object_name)
# Next, apply any overridden values from 'class Meta'.
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
# Ignore any private attributes that Django doesn't care about.
# NOTE: We can't modify a dictionary's contents while looping
# over it, so we loop over the *original* dictionary instead.
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
# unique_together can be either a tuple of tuples, or a single
# tuple of two strings. Normalize it to a tuple of tuples, so that
# calling code can uniformly expect that.
ut = meta_attrs.pop('unique_together', self.unique_together)
if ut and not isinstance(ut[0], (tuple, list)):
ut = (ut,)
self.unique_together = ut
# verbose_name_plural is a special case because it uses a 's'
# by default.
if self.verbose_name_plural is None:
self.verbose_name_plural = string_concat(self.verbose_name, 's')
# Any leftover attributes must be invalid.
if meta_attrs != {}:
raise TypeError("'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()))
else:
self.verbose_name_plural = string_concat(self.verbose_name, 's')
del self.meta
# If the db_table wasn't provided, use the app_label + module_name.
if not self.db_table:
self.db_table = "%s_%s" % (self.app_label, self.module_name)
self.db_table = truncate_name(self.db_table, connection.ops.max_name_length())
def view(request):
results = None
query = None
form = self.form(request.GET)
name = get_verbose_name(type(self).__name__).replace(' ','_')
if form.is_valid():
results = self.get_results(form.cleaned_data, request)
query = form.cleaned_data
context = {
'form': form,
'results': results,
'query_data': query
}
template = getattr(self, 'results_template', 'search/results_%s.html' % name)
return TemplateResponse(request, template, context)
def __new__(cls, name, bases, attrs):
super_new = super(CMSPluginBaseMetaclass, cls).__new__
parents = [base for base in bases if isinstance(base, CMSPluginBaseMetaclass)]
if not parents:
# If this is CMSPluginBase itself, and not a subclass, don't do anything
return super_new(cls, name, bases, attrs)
new_plugin = super_new(cls, name, bases, attrs)
# validate model is actually a CMSPlugin subclass.
if not issubclass(new_plugin.model, CMSPlugin):
raise SubClassNeededError(
"The 'model' attribute on CMSPluginBase subclasses must be "
"either CMSPlugin or a subclass of CMSPlugin. %r on %r is not." % (new_plugin.model, new_plugin)
)
# validate the template:
if not hasattr(new_plugin, "render_template"):
raise ImproperlyConfigured("CMSPluginBase subclasses must have a render_template attribute")
# Set the default form
if not new_plugin.form:
form_meta_attrs = {
"model": new_plugin.model,
"exclude": ("position", "placeholder", "language", "plugin_type"),
}
form_attrs = {"Meta": type("Meta", (object,), form_meta_attrs)}
new_plugin.form = type("%sForm" % name, (ModelForm,), form_attrs)
# Set the default fieldsets
if not new_plugin.fieldsets:
basic_fields = []
advanced_fields = []
for f in new_plugin.model._meta.fields:
if not f.auto_created and f.editable:
if hasattr(f, "advanced"):
advanced_fields.append(f.name)
else:
basic_fields.append(f.name)
if advanced_fields:
new_plugin.fieldsets = [
(None, {"fields": basic_fields}),
(_("Advanced options"), {"fields": advanced_fields, "classes": ("collapse",)}),
]
# Set default name
if not new_plugin.name:
new_plugin.name = get_verbose_name(new_plugin.__name__)
return new_plugin
def __init__(self, model):
self.model = model
self.model_name = self.model._class_name
## Set defaults
if not self.list_items:
self.list_items.append('__unicode__')
if not self.verbose_name:
self.verbose_name = get_verbose_name(self.model_name)
if not self.verbose_name_plural:
self.verbose_name_plural = '%ss' % self.verbose_name
## Validations
for attr in self.list_items:
if not hasattr(self.model, attr):
raise ValueError('%s is not an attribute of %s' % (attr, self.model._class_name))
if not issubclass(MongoAdminForm, self.form):
raise TypeError('Form must be subclass of MongoAdminForm')
def contribute_to_class(self, cls, name):
cls._meta = self
self.object_name = cls.__name__
self.verbose_name = get_verbose_name(self.object_name)
if self.meta:
if hasattr(self.meta, 'cf'):
self.object_name = self.meta.cf
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES + TRANSIT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
if getattr(settings, 'RUNNING_TESTS', False):
self.keyspace = 'test_%s' % self.keyspace
cls.add_to_class('objects', Manager())
del self.meta
def contribute_to_class(self, cls, name):
cls._meta = self
self.object_name = cls.__name__
self.verbose_name = get_verbose_name(self.object_name)
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self, attr_name, meta_attrs.pop(attr_name))
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
if not self.keyspace:
raise ConfigurationError(u"No keyspace defined! Define keyspace in your model's Meta class or CASSANDRA_KEYSPACE in settings.py")
if getattr(settings, 'RUNNING_TESTS', False):
self.keyspace = 'test_%s' % self.keyspace
cls.add_to_class('objects', Manager())
del self.meta
def reverse_translate_query(query):
new_query_string=u''
for i in query.lists():
# modelname=i[0]
modelstring=get_verbose_name(i[0])
value=i[1]
if modelstring in fixed_fields:
new_query_string+="&"+modelstring+"="+value[0]
elif modelstring[0:7]=='incluir':
new_query_string+="&"+modelstring
else:
modelname=' '.join(modelstring.split()[1:])
appname=modelstring.split()[0]
ctype_list = ContentType.objects.filter(app_label=appname,name=modelname)
if len(ctype_list) > 0:
ctype=ctype_list[0]
model_class=ctype.model_class()
for b in value:
d=model_class.objects.filter(pk=b)
if len(d) > 0:
new_query_string+="&"+modelstring+"="+d[0].nombre
new_query_string=new_query_string.lstrip("&")
return new_query_string
def _update_from_name(self, name):
self.name = name
self.verbose_name = self.verbose_name or get_verbose_name(name)
self.verbose_name_plural = self.verbose_name_plural or self.verbose_name + 's'
def get_field_label(self, field):
if hasattr(field, "verbose_name"):
return field.verbose_name
return capfirst(get_verbose_name(field.name))
def create_verbose_name(name):
name = get_verbose_name(name)
name.replace("_", " ")
return name
def get_field_label(self, field):
if field.verbose_name:
return field.verbose_name
return capfirst(get_verbose_name(field.name))
def verbose_name(self):
"""
This is used in templates to get a label for titles under this category
"""
return get_verbose_name(type(self).__name__)
def get_field_label(self, field):
if hasattr(field, 'verbose_name'):
return field.verbose_name
return capfirst(get_verbose_name(field.name))
def _update_from_name(self, name):
self.name = name
self.verbose_name = self.verbose_name or get_verbose_name(name)
self.verbose_name_plural = self.verbose_name_plural or self.verbose_name + 's'
def create_verbose_name(name):
name = get_verbose_name(name)
name = name.replace('_', ' ')
return name
def create_verbose_name(name):
name = get_verbose_name(name)
name.replace('_', ' ')
return name
def get_verbose_name_plural(self):
try:
return capfirst(get_verbose_name(self._meta['verbose_name_plural']))
except KeyError:
return capfirst(get_verbose_name('%s' % self.verbose_name))
def get_field_label(self, field):
if field.verbose_name:
return field.verbose_name
return capfirst(get_verbose_name(field.name))