def make_display_filter(feature_name):
Feature = MapFeature.get_subclass(feature_name)
if hasattr(Feature, "display_name_plural"):
plural = Feature.display_name_plural
else:
plural = Feature.display_name + "s"
return {"label": "Show %s" % plural.lower(), "model": feature_name}
def add_map_feature_types(self, types):
"""
add_map_feature_types(self, types)
types is a list of map feature class names.
Add these types to the instance config,
save the instance!!!,
and create udf rows for udfs that have settings defaults,
if they don't already exist.
"""
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self._map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def make_display_filter(feature_name):
Feature = MapFeature.get_subclass(feature_name)
plural = Feature.terminology(self)['plural']
return {
'label': 'Show %s' % plural.lower(),
'model': feature_name
}
def add_map_feature_types(self, types):
"""
add_map_feature_types(self, types)
types is a list of map feature class names.
Add these types to the instance config,
save the instance!!!,
and create udf rows for udfs that have settings defaults,
if they don't already exist.
"""
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self._map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def render_map_feature_add(request, instance, type):
if type in instance.map_feature_types[1:]:
app = MapFeature.get_subclass(type).__module__.split(".")[0]
template = "%s/%s_add.html" % (app, type)
return render_to_response(template, None, RequestContext(request))
else:
raise Http404("Instance does not support feature type " + type)
def make_display_filter(feature_name):
Feature = MapFeature.get_subclass(feature_name)
if hasattr(Feature, 'display_name_plural'):
plural = Feature.display_name_plural
else:
plural = Feature.display_name + 's'
return {'label': 'Show %s' % plural.lower(), 'model': feature_name}
def get_map_view_context(request, instance):
resource_classes = [
MapFeature.get_subclass(type) for type in instance.map_feature_types
]
return {
'fields_for_add_tree': [(trans('Tree Height'), 'Tree.height')],
'resource_classes': resource_classes[1:]
}
def get_map_view_context(request, instance):
resource_classes = [MapFeature.get_subclass(type)
for type in instance.map_feature_types]
return {
'fields_for_add_tree': [
(trans('Tree Height'), 'Tree.height')
],
'resource_classes': resource_classes[1:]
}
def render_map_feature_add(request, instance, type):
if type in instance.map_feature_types[1:]:
app = MapFeature.get_subclass(type).__module__.split('.')[0]
try:
template = '%s/%s_add.html' % (app, type)
except:
template = 'treemap/resource_add.html'
return render(request, template, {'object_name': to_object_name(type)})
else:
raise_non_instance_404(type)
def _get_map_view_context(request, instance):
resource_types = [{'name': type,
'display': MapFeature.get_subclass(type).display_name}
for type in instance.map_feature_types]
return {
'fields_for_add_tree': [
(trans('Tree Height'), 'Tree.height')
],
'resource_types': resource_types[1:]
}
def render_map_feature_add(request, instance, type):
if type in instance.map_feature_types[1:]:
app = MapFeature.get_subclass(type).__module__.split('.')[0]
try:
template = '%s/%s_add.html' % (app, type)
except:
template = 'treemap/resource_add.html'
return render(request, template, {'object_name': to_object_name(type)})
else:
raise_non_instance_404(type)
def make_display_filter(feature_name):
Feature = MapFeature.get_subclass(feature_name)
if hasattr(Feature, 'display_name_plural'):
plural = Feature.display_name_plural
else:
plural = Feature.display_name + 's'
return {
'label': 'Show %s' % plural.lower(),
'model': feature_name
}
def any_resource_is_creatable(role_related_obj):
role = _get_role_from_related_object(role_related_obj)
if role is None:
return False
map_features = {MapFeature.get_subclass(m)
for m in role.instance.map_feature_types}
resources = map_features - {Plot}
return any(map_feature_is_creatable(role, Model) for Model in resources)
def get_map_view_context(request, instance):
resource_classes = [MapFeature.get_subclass(type)
for type in instance.map_feature_types]
context = {
'fields_for_add_tree': [
(_('Tree Height'), 'Tree.height')
],
'resource_classes': resource_classes[1:],
}
add_map_info_to_context(context, instance)
return context
def render_map_feature_add(request, instance, type):
if type in instance.map_feature_types[1:]:
app = MapFeature.get_subclass(type).__module__.split(".")[0]
try:
template = "%s/%s_add.html" % (app, type)
get_template(template)
except:
template = "treemap/resource_add.html"
return render_to_response(template, {"object_name": to_object_name(type)}, RequestContext(request))
else:
raise_non_instance_404(type)
def any_resource_is_creatable(role_related_obj):
role = _get_role_from_related_object(role_related_obj)
if role is None:
return False
map_features = {
MapFeature.get_subclass(m)
for m in role.instance.map_feature_types
}
resources = map_features - {Plot}
return any(map_feature_is_creatable(role, Model) for Model in resources)
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Return the concrete subtype (e.g. Plot), not a general MapFeature
return feature.cast_to_subtype()
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Return the concrete subtype (e.g. Plot), not a general MapFeature
return feature.cast_to_subtype()
def render_map_feature_add(request, instance, type):
if type in instance.map_feature_types[1:]:
app = MapFeature.get_subclass(type).__module__.split('.')[0]
try:
template = '%s/%s_add.html' % (app, type)
get_template(template)
except:
template = 'treemap/resource_add.html'
return render_to_response(template,
{'object_name': to_object_name(type)},
RequestContext(request))
else:
raise Http404('Instance does not support feature type ' + type)
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Use feature_type to get the appropriate object, e.g. feature.plot
feature = getattr(feature, feature.feature_type.lower())
return feature
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Use feature_type to get the appropriate object, e.g. feature.plot
feature = getattr(feature, feature.feature_type.lower())
return feature
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
if type not in instance.map_feature_types:
raise_non_instance_404(type)
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Return the concrete subtype (e.g. Plot), not a general MapFeature
typed_feature = feature.cast_to_subtype()
class_name = typed_feature.__class__.__name__
if class_name not in instance.map_feature_types:
raise_non_instance_404(class_name)
return typed_feature
def get_map_feature_or_404(feature_id, instance, type=None):
if type:
if type not in instance.map_feature_types:
raise_non_instance_404(type)
MapFeatureSubclass = MapFeature.get_subclass(type)
InstanceMapFeature = instance.scope_model(MapFeatureSubclass)
return get_object_or_404(InstanceMapFeature, pk=feature_id)
else:
InstanceMapFeature = instance.scope_model(MapFeature)
feature = get_object_or_404(InstanceMapFeature, pk=feature_id)
# Return the concrete subtype (e.g. Plot), not a general MapFeature
typed_feature = feature.cast_to_subtype()
class_name = typed_feature.__class__.__name__
if class_name not in instance.map_feature_types:
raise_non_instance_404(class_name)
return typed_feature
def add_map_feature_types(self, types):
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self.map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def add_map_feature_types(self, types):
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self.map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def safe_get_model_class(model_string):
"""
In a couple of cases we want to be able to convert a string
into a valid django model class. For instance, if we have
'Plot' we want to get the actual class for 'treemap.models.Plot'
in a safe way.
This function returns the class represented by the given model
if it exists in 'treemap.models'
"""
from treemap.models import MapFeature
# All of our models live in 'treemap.models', so
# we can start with that namespace
models_module = __import__('treemap.models')
if hasattr(models_module.models, model_string):
return getattr(models_module.models, model_string)
elif MapFeature.has_subclass(model_string):
return MapFeature.get_subclass(model_string)
else:
raise ValidationError(trans('invalid model type: "%s"') % model_string)
def safe_get_model_class(model_string):
"""
In a couple of cases we want to be able to convert a string
into a valid django model class. For instance, if we have
'Plot' we want to get the actual class for 'treemap.models.Plot'
in a safe way.
This function returns the class represented by the given model
if it exists in 'treemap.models'
"""
from treemap.models import MapFeature
# All of our models live in 'treemap.models', so
# we can start with that namespace
models_module = __import__('treemap.models')
if hasattr(models_module.models, model_string):
return getattr(models_module.models, model_string)
elif MapFeature.has_subclass(model_string):
return MapFeature.get_subclass(model_string)
else:
raise ValidationError(trans('invalid model type'))
def model_perm_models(instance):
return {Instance, Tree, TreePhoto, MapFeaturePhoto} | {
MapFeature.get_subclass(m)
for m in instance.map_feature_types
}
def model_perm_models(instance):
return {Instance, Tree, TreePhoto, MapFeaturePhoto} | {
MapFeature.get_subclass(m) for m in instance.map_feature_types}
def field_perm_models(instance):
return {Tree} | {MapFeature.get_subclass(m)
for m in instance.map_feature_types}
def field_perm_models(instance):
return {Tree} | {
MapFeature.get_subclass(m)
for m in instance.map_feature_types
}
def get_plural_feature_name(feature_name):
if feature_name == 'Tree':
Feature = Tree
else:
Feature = MapFeature.get_subclass(feature_name)
return Feature.terminology(instance)['plural']
def add_map_feature(request, instance, type='Plot'):
if type not in instance.map_feature_types:
raise_non_instance_404(type)
feature = MapFeature.get_subclass(type)(instance=instance)
return _request_to_update_map_feature(request, feature)
def add_map_feature(request, instance, type='Plot'):
if type not in instance.map_feature_types:
raise_non_instance_404(type)
feature = MapFeature.get_subclass(type)(instance=instance)
return _request_to_update_map_feature(request, feature)
def make_display_filter(feature_name):
feature = MapFeature.get_subclass(feature_name)()
return {
'label': 'Show %ss' % feature.display_name,
'in_value': feature_name
}
def map_feature_classes(self):
from treemap.models import MapFeature
classes = {MapFeature.get_subclass(m) for m in self.map_feature_types}
return classes
def get_plural_feature_name(feature_name):
if feature_name == 'Tree':
Feature = Tree
else:
Feature = MapFeature.get_subclass(feature_name)
return Feature.terminology(instance)['plural']
def map_feature_classes(self):
from treemap.models import MapFeature
classes = {MapFeature.get_subclass(m)
for m in self.map_feature_types}
return classes
