def create_subclass(self, params, **kwargs):
"""
Subclasses the LayerSelectionResource instance's class for the given config_entity and layer.
:param params Must contain a 'config_entity__id' and 'layer__id'
:return:
"""
layer = self.resolve_layer(params)
config_entity = self.resolve_config_entity(params)
logger.debug(
"Resolving LayerSelection for config_entity %s, layer %s" %
(config_entity.key, layer.db_entity.key))
layer_selection_class = get_or_create_layer_selection_class_for_layer(
layer, config_entity)
# Have the LayerPublisher create the LayerSelection instance for the user if needed
update_or_create_layer_selections_for_layer(
layer, users=[self.resolve_user(params)])
if not layer_selection_class:
raise Exception(
"Layer with db_entity_key %s has no feature_class. Its LayerSelections should not be requested"
% layer.db_entity_key)
return get_dynamic_resource_class(self.__class__,
layer_selection_class)
def create_layer_selection(config_entity, layer, attribute_id):
db_entity = layer.db_entity_interest.db_entity
connection = connection_dict(layer.config_entity.db)
tilestache_layers = []
users = set(get_users_with_perms(config_entity)) | set(
get_users_with_perms(layer.db_entity_interest.db_entity))
# Make sure layer_selection instances exist for the users
from footprint.main.publishing.layer_publishing import update_or_create_layer_selections_for_layer
update_or_create_layer_selections_for_layer(layer, users=users)
logger.info("Get/Create layer_selection for config_entity %s, layer %s, users %s" %\
(config_entity.key, layer.db_entity_key, ','.join(map(lambda user: user.username, users))))
# Each layer has a dynamic class representing its SelectedFeature table
get_or_create_layer_selection_class_for_layer(layer)
if not users:
return tilestache_layers
config_entity.db_entity_feature_class(key=layer.db_entity_key)
layer_selection_class = get_or_create_layer_selection_class_for_layer(
layer, config_entity)
# Take the first user to create a template query
user = list(users)[0]
# Each LayerSelection instance is per user
layer_selection = layer_selection_class.objects.get_or_create(user=user)[0]
# Extract the query from the QuerySet
query = re.sub(
r'"layer_selection_id" = \d+', r'"layer_selection_id" = {user_id}',
str(
layer_selection.selected_features.values('wkb_geometry',
'id').query))
logger.info(
"Creating tilestache layer_selection for layer %s, user %s, query: %s"
% (layer.full_name, user.username, query))
user_id_lookup = map_to_dict(
lambda layer_selection: [layer_selection.user.id, layer_selection.id],
layer_selection_class.objects.all())
# Embed the id in the Geojson for each feature.
# Nothing else is needed, since all other attributes can be looked up based on the id
id_field = map(lambda field: field.name + '_id',
layer_selection.feature_class._meta.parents.values())[0]
vector_selection_layer = build_vector_layer_config(
parameters=merge(
connection,
dict(query=query,
column="wkb_geometry",
user_id_lookup=user_id_lookup)),
provider_id_property=id_field,
client_id_property=db_entity._meta.pk.name)
layer_key = "layer:{layer},attr_id:{attribute},type:{type}".format(
layer=layer.id, attribute=attribute_id, type='selection')
logger.info("Creating layer %s" % layer_key)
tilestache_layers.append(
TSLayer(key=layer_key, value=vector_selection_layer))
return tilestache_layers
def resolve_layer_selection(self, params):
"""
Used to get that actual selected features, which is a short cut querying, so we don't have to query
for potentially thousands of ids. If No layer exists then there is also no LayerSelection, in which case
we return None
"""
layer = self.resolve_layer(params)
config_entity = self.resolve_config_entity(params)
if not layer:
return None
update_or_create_layer_selections_for_layer(layer, users=[self.resolve_user(params)])
layer_selection_class = get_or_create_layer_selection_class_for_layer(layer, config_entity, False)
return layer_selection_class.objects.get(user=self.resolve_user(params))
def resolve_layer_selection(self, params):
"""
Used to get that actual selected features, which is a short cut querying, so we don't have to query
for potentially thousands of ids. If No layer exists then there is also no LayerSelection, in which case
we return None
"""
layer = self.resolve_layer(params)
config_entity = self.resolve_config_entity(params)
if not layer:
return None
update_or_create_layer_selections_for_layer(
layer, users=[self.resolve_user(params)])
layer_selection_class = get_or_create_layer_selection_class_for_layer(
layer, config_entity, False)
return layer_selection_class.objects.get(
user=self.resolve_user(params))
def create_layer_selection(config_entity, layer, attribute_id):
db_entity = layer.db_entity_interest.db_entity
connection = connection_dict(layer.config_entity.db)
tilestache_layers = []
users = set(get_users_with_perms(config_entity)) | set(get_users_with_perms(layer.db_entity_interest.db_entity))
# Make sure layer_selection instances exist for the users
from footprint.main.publishing.layer_publishing import update_or_create_layer_selections_for_layer
update_or_create_layer_selections_for_layer(layer, users=users)
logger.info("Get/Create layer_selection for config_entity %s, layer %s, users %s" %\
(config_entity.key, layer.db_entity_key, ','.join(map(lambda user: user.username, users))))
# Each layer has a dynamic class representing its SelectedFeature table
get_or_create_layer_selection_class_for_layer(layer)
if not users:
return tilestache_layers
config_entity.db_entity_feature_class(key=layer.db_entity_key)
layer_selection_class = get_or_create_layer_selection_class_for_layer(layer, config_entity)
# Take the first user to create a template query
user = list(users)[0]
# Each LayerSelection instance is per user
layer_selection = layer_selection_class.objects.get_or_create(user=user)[0]
# Extract the query from the QuerySet
query = re.sub(
r'"layer_selection_id" = \d+',
r'"layer_selection_id" = {user_id}',
str(layer_selection.selected_features.values('wkb_geometry', 'id').query))
logger.info("Creating tilestache layer_selection for layer %s, user %s, query: %s" % (layer.full_name, user.username, query))
user_id_lookup = map_to_dict(lambda layer_selection: [layer_selection.user.id, layer_selection.id], layer_selection_class.objects.all())
# Embed the id in the Geojson for each feature.
# Nothing else is needed, since all other attributes can be looked up based on the id
id_field = map(lambda field: field.name + '_id', layer_selection.feature_class._meta.parents.values())[0]
vector_selection_layer = build_vector_layer_config(
parameters=merge(connection, dict(query=query, column="wkb_geometry", user_id_lookup=user_id_lookup)),
provider_id_property=id_field,
client_id_property=db_entity._meta.pk.name
)
layer_key = "layer:{layer},attr_id:{attribute},type:{type}".format(layer=layer.id, attribute=attribute_id, type='selection')
logger.info("Creating layer %s" % layer_key)
tilestache_layers.append(TSLayer(key=layer_key, value=vector_selection_layer))
return tilestache_layers
def create_subclass(self, params, **kwargs):
"""
Subclasses the LayerSelectionResource instance's class for the given config_entity and layer.
:param params Must contain a 'config_entity__id' and 'layer__id'
:return:
"""
layer = self.resolve_layer(params)
config_entity = self.resolve_config_entity(params)
logger.debug("Resolving LayerSelection for config_entity %s, layer %s" % (config_entity.key, layer.db_entity.key))
layer_selection_class = get_or_create_layer_selection_class_for_layer(layer, config_entity)
# Have the LayerPublisher create the LayerSelection instance for the user if needed
update_or_create_layer_selections_for_layer(layer, users=[self.resolve_user(params)])
if not layer_selection_class:
raise Exception("Layer with db_entity_key %s has no feature_class. Its LayerSelections should not be requested" % layer.db_entity_key)
return get_dynamic_resource_class(
self.__class__,
layer_selection_class
)
