def dynamic_resource_subclass(self, layer_selection=None, db_entity=None, feature_class=None, config_entity=None, metadata=None, params=None, **kwargs):
"""
Creates the dynamic Feature Resource class by passing in a layer_selection, db_entity, or feature_class
:param layer_selection: Required if db_entity or metadata aren't present
:param db_entity: Required if layer_selection or metadata aren't present
:param metadata: Required along with config_entity if layer_selection or db_entity aren't present
:param kwargs:
:return:
"""
feature_class_configuration = None
if layer_selection:
# Coming in relative to a LayerSelection, which puts us in the context of the LayerSelection's
# feature query for this Feature subclass
layer = layer_selection.layer
# If we pass in a ConfigEntity it means we want to scope the Feature class to its scope.
# The ConfigEntity defaults to that of the Layer, but we can override it to be a lower
# scope to make sure that we have access to lower DbEntities of performing joins
config_entity = config_entity.subclassed if config_entity else layer.config_entity.subclassed
logger.debug("Resolving FeatureResource subclass for layer_selection: {0}, config_entity: {1}".format(layer_selection.unique_id, config_entity.id))
# Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities
# of the ConfigEntity for joins
feature_class = config_entity.db_entity_feature_class(layer.db_entity.key)
elif db_entity:
# Coming in relative to a DbEntity, meaning we don't care about a particular LayerSelection's
# feature query for this Feature subclass
config_entity = db_entity.config_entity
logger.debug("Resolving FeatureResource subclass for db_entity: {0}, config_entity: {1}".format(db_entity.id, config_entity.id))
# Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities
# of the ConfigEntity for joins
feature_class = config_entity.db_entity_feature_class(db_entity.key)
elif metadata:
# Coming in with metadata, meaning this is and uploaded or ArcGis table with no DbEntity yet
# We need to construct a FeatureClass from the metadata
logger.debug("Resolving FeatureResource subclass for metadata: {0}, config_entity: {1}".format(metadata, config_entity.id))
feature_class_creator = FeatureClassCreator(
config_entity
)
feature_class_configuration = feature_class_creator.feature_class_configuration_from_metadata(metadata['schema'])
feature_class = FeatureClassCreator(
config_entity,
feature_class_configuration
).dynamic_model_class()
if not feature_class_configuration:
# If we didn't already ensure all dynamic model classes have been created
# This only need to run once to get all dynamic feature subclasses into memory,
# in case they are needed by an association, join, or something similar
feature_class_creator = FeatureClassCreator.from_dynamic_model_class(feature_class)
feature_class_creator.ensure_dynamic_models()
logger.debug("Resolving resource for Feature subclass: {0}".format(feature_class))
# Resolve the FeatureResource subclass based on the given Feature subclass
# If self is already a subclass, just return self
# Else, return a preconfigured subclass or one dynamically created. The latter will probably be the only way in the future.
# If not already subclassed
is_singleton_feature = issubclass(self.__class__, SingletonFeatureResourceMixin)
is_template_feature = self.__class__ == TemplateFeatureResource
if self.__class__ in [FeatureResource, TemplateFeatureResource, FeatureCategoryAttributeResource,
FeatureQuantitativeAttributeResource]:
if is_singleton_feature or params.get('is_feature_attribute'):
queryset = feature_class.objects.none()
elif kwargs.get('method', None) == 'PATCH':
# It's possible to PATCH with an active join query.
# But we don't want to use a join query when patching
queryset = feature_class.objects.all()
else:
# Get the queryset stored by the layer_selection or an empty query if we don't have a layer_selection
queryset = layer_selection.selected_features_or_values if\
layer_selection else \
feature_class.objects.none()
if layer_selection and not (is_singleton_feature or kwargs.get('query_may_be_empty')) and queryset.count()==0:
raise Exception(
"Unexpected empty queryset for layer_selection features: %s" %
queryset.query)
is_values_queryset = isinstance(queryset, ValuesQuerySet)
#returns queryset ordered by the table id
queryset = queryset.order_by('id')
if is_values_queryset:
join_feature_class = layer_selection.create_join_feature_class() if is_values_queryset else feature_class
logger.info("Created join_feature_class: %s" % join_feature_class)
# Force the queryset to our new class so that Tastypie can map the dict results to it
queryset.model = join_feature_class
return self.__class__.resolve_resource_class(
join_feature_class,
queryset=queryset,
base_resource_class=self.join_feature_resource_class(join_feature_class),
additional_fields_dict=dict(
# Pass these to the feature resource to help it resolve
# field mappings and add related fields (just need for join_feature_class)
# Use the layer_selection if it exists since it might have filtered or extra query fields
result_field_lookup=(layer_selection or db_entity).result_field_lookup if not metadata else {},
related_field_lookup=(layer_selection or db_entity).related_field_lookup if not metadata else {},
# We use these in the FeatureResource to create a unique id for each join Feature
join_model_attributes=layer_selection and layer_selection.result_map.join_model_attributes
),
is_join_query=True,
limit_fields=layer_selection.result_map['result_fields']
)
else:
abstract_feature_resource_class = self.__class__
resource_class = abstract_feature_resource_class.resolve_resource_class(
feature_class,
queryset=queryset,
# Give FeatureResource a reference to the layer_selection
additional_fields_dict=merge(
dict(
# Pass this to the feature resource to help it resolve field mappings
result_field_lookup=(layer_selection or db_entity).result_field_lookup if not metadata else {}
),
dict(
# Not sure why it doesn't work to just stick this on the TemplateFeatureResource
feature_fields=ListField(attribute='feature_fields', null=True, blank=True, readonly=True),
feature_field_title_lookup=PickledDictField(attribute='feature_field_title_lookup', null=True, blank=True, readonly=True),
) if is_template_feature else dict()
),
for_template=is_template_feature
)
return resource_class
return self
def dynamic_resource_subclass(self,
layer_selection=None,
db_entity=None,
feature_class=None,
config_entity=None,
metadata=None,
params=None,
**kwargs):
"""
Creates the dynamic Feature Resource class by passing in a layer_selection, db_entity, or feature_class
:param layer_selection: Required if db_entity or metadata aren't present
:param db_entity: Required if layer_selection or metadata aren't present
:param metadata: Required along with config_entity if layer_selection or db_entity aren't present
:param kwargs:
:return:
"""
feature_class_configuration = None
if layer_selection:
# Coming in relative to a LayerSelection, which puts us in the context of the LayerSelection's
# feature query for this Feature subclass
layer = layer_selection.layer
# If we pass in a ConfigEntity it means we want to scope the Feature class to its scope.
# The ConfigEntity defaults to that of the Layer, but we can override it to be a lower
# scope to make sure that we have access to lower DbEntities of performing joins
config_entity = config_entity.subclassed if config_entity else layer.config_entity.subclassed
logger.debug(
"Resolving FeatureResource subclass for layer_selection: {0}, config_entity: {1}"
.format(layer_selection.unique_id, config_entity.id))
# Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities
# of the ConfigEntity for joins
feature_class = config_entity.db_entity_feature_class(
layer.db_entity.key)
elif db_entity:
# Coming in relative to a DbEntity, meaning we don't care about a particular LayerSelection's
# feature query for this Feature subclass
config_entity = db_entity.config_entity
logger.debug(
"Resolving FeatureResource subclass for db_entity: {0}, config_entity: {1}"
.format(db_entity.id, config_entity.id))
# Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities
# of the ConfigEntity for joins
feature_class = config_entity.db_entity_feature_class(
db_entity.key)
elif metadata:
# Coming in with metadata, meaning this is and uploaded or ArcGis table with no DbEntity yet
# We need to construct a FeatureClass from the metadata
logger.debug(
"Resolving FeatureResource subclass for metadata: {0}, config_entity: {1}"
.format(metadata, config_entity.id))
feature_class_creator = FeatureClassCreator(config_entity)
feature_class_configuration = feature_class_creator.feature_class_configuration_from_metadata(
metadata['schema'])
feature_class = FeatureClassCreator(
config_entity,
feature_class_configuration).dynamic_model_class()
if not feature_class_configuration:
# If we didn't already ensure all dynamic model classes have been created
# This only need to run once to get all dynamic feature subclasses into memory,
# in case they are needed by an association, join, or something similar
feature_class_creator = FeatureClassCreator.from_dynamic_model_class(
feature_class)
feature_class_creator.ensure_dynamic_models()
logger.debug("Resolving resource for Feature subclass: {0}".format(
feature_class))
# Resolve the FeatureResource subclass based on the given Feature subclass
# If self is already a subclass, just return self
# Else, return a preconfigured subclass or one dynamically created. The latter will probably be the only way in the future.
# If not already subclassed
is_singleton_feature = issubclass(self.__class__,
SingletonFeatureResourceMixin)
is_template_feature = self.__class__ == TemplateFeatureResource
if self.__class__ in [
FeatureResource, TemplateFeatureResource,
FeatureCategoryAttributeResource,
FeatureQuantitativeAttributeResource
]:
if is_singleton_feature or params.get('is_feature_attribute'):
queryset = feature_class.objects.none()
elif kwargs.get('method', None) == 'PATCH':
# It's possible to PATCH with an active join query.
# But we don't want to use a join query when patching
queryset = feature_class.objects.all()
else:
# Get the queryset stored by the layer_selection or an empty query if we don't have a layer_selection
queryset = layer_selection.selected_features_or_values if\
layer_selection else \
feature_class.objects.none()
if layer_selection and not (is_singleton_feature or kwargs.get(
'query_may_be_empty')) and queryset.count() == 0:
raise Exception(
"Unexpected empty queryset for layer_selection features: %s"
% queryset.query)
is_values_queryset = isinstance(queryset, ValuesQuerySet)
#returns queryset ordered by the table id
queryset = queryset.order_by('id')
if is_values_queryset:
join_feature_class = layer_selection.create_join_feature_class(
) if is_values_queryset else feature_class
logger.info("Created join_feature_class: %s" %
join_feature_class)
# Force the queryset to our new class so that Tastypie can map the dict results to it
queryset.model = join_feature_class
return self.__class__.resolve_resource_class(
join_feature_class,
queryset=queryset,
base_resource_class=self.join_feature_resource_class(
join_feature_class),
additional_fields_dict=dict(
# Pass these to the feature resource to help it resolve
# field mappings and add related fields (just need for join_feature_class)
# Use the layer_selection if it exists since it might have filtered or extra query fields
result_field_lookup=(layer_selection
or db_entity).result_field_lookup
if not metadata else {},
related_field_lookup=(
layer_selection or db_entity).related_field_lookup
if not metadata else {},
# We use these in the FeatureResource to create a unique id for each join Feature
join_model_attributes=layer_selection
and layer_selection.result_map.join_model_attributes),
is_join_query=True,
limit_fields=layer_selection.result_map['result_fields'])
else:
abstract_feature_resource_class = self.__class__
resource_class = abstract_feature_resource_class.resolve_resource_class(
feature_class,
queryset=queryset,
# Give FeatureResource a reference to the layer_selection
additional_fields_dict=merge(
dict(
# Pass this to the feature resource to help it resolve field mappings
result_field_lookup=(layer_selection or db_entity).
result_field_lookup if not metadata else {}),
dict(
# Not sure why it doesn't work to just stick this on the TemplateFeatureResource
feature_fields=ListField(
attribute='feature_fields',
null=True,
blank=True,
readonly=True),
feature_field_title_lookup=PickledDictField(
attribute='feature_field_title_lookup',
null=True,
blank=True,
readonly=True),
) if is_template_feature else dict()),
for_template=is_template_feature)
return resource_class
return self
