def on_config_entity_post_save_layer(sender, **kwargs): """ Sync tilestache to a ConfigEntity class after the latter is saved :param **kwargs: optional "db_entity_keys" to limit the layers created to those DbEntities """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture # Disable post save publishing on individual layers. The ConfigEntity is controlling publishing config_entity = InstanceBundle.extract_single_instance(**kwargs) logger.info("Handler: on_config_entity_post_save_layer for %s" % config_entity.full_name) # Create LayerLibrary instances based on each LayerLibrary configuration if the configuration's scope # matches that of config_entity client_layer_fixture = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) layer_library_configurations = FixtureList(client_layer_fixture.layer_libraries()).matching_scope( class_scope=config_entity.__class__ ) logger.info("Processing LayerLibrary Configurations %s" % ', '.join(map( lambda layer_library_configuration: layer_library_configuration.key, layer_library_configurations))) for layer_library_configuration in layer_library_configurations: _update_or_create_layer_library_and_layers(config_entity, layer_library_configuration, **kwargs) reset_queries()
def on_config_entity_post_save_layer(sender, **kwargs): """ Sync tilestache to a ConfigEntity class after the latter is saved :param **kwargs: optional "db_entity_keys" to limit the layers created to those DbEntities """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture # Disable post save publishing on individual layers. The ConfigEntity is controlling publishing config_entity = InstanceBundle.extract_single_instance(**kwargs) logger.info("Handler: on_config_entity_post_save_layer for %s" % config_entity.full_name) # Create LayerLibrary instances based on each LayerLibrary configuration if the configuration's scope # matches that of config_entity client_layer_fixture = resolve_fixture("presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) layer_library_configurations = FixtureList( client_layer_fixture.layer_libraries()).matching_scope( class_scope=config_entity.__class__) logger.info("Processing LayerLibrary Configurations %s" % ', '.join( map( lambda layer_library_configuration: layer_library_configuration. key, layer_library_configurations))) for layer_library_configuration in layer_library_configurations: _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, **kwargs) reset_queries()
def on_layer_post_save_db_entity_process_layer(sender, **kwargs): """ For db_entity create/update/clone, this creates or updates the layer """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture db_entity_interest = InstanceBundle.extract_single_instance(**kwargs) config_entity = db_entity_interest.config_entity.subclassed db_entity = db_entity_interest.db_entity logger.info("Handler: on_layer_post_save_db_enitty_process_layer for DbEntity: key %s, id %s" % (db_entity.key, db_entity.id)) # Return if the db_entity was not created from an user imported feature # Configured layer saving is handled by after saving the ConfigEntity if not db_entity.feature_class_configuration.generated: return layer_configuration_fixture = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) # Update the layer via the layer library update_or_create # Find LayerLibraries matching the ConfigEntity class schope for layer_library_configuration in layer_configuration_fixture.layer_libraries(): logger.info("Handler: Layer Library Configuration: %s" % layer_library_configuration) # Update/Create the layer library and layers _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, db_entity_keys=[db_entity.key])
def resolve_layer_configuration(config_entity, db_entity_key, layer): """ Creates a LayerConfiguration for imported layers using the template LayerConfigurations designed in the LayerConfigurationFixture.import_layer_configurations """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture # if a layer exists and it has a layer configuration update it if layer and layer.configuration: layer_configuration = LayerConfiguration(**merge( dict( db_entity_key=layer.db_entity_key, layer_library_key=layer.key, visible=layer.visible, # Convert the LayerStyle to a dict, which is what a LayerConfiguration expects, and wipe out the ids layer_style=model_dict(layer.medium)), dict( built_form_set_key=layer.configuration. get('built_form_key', None), sort_priority=layer.configuration.get('sort_priority', None), attribute_sort_priority=layer.configuration. get('attribute_sort_priority', None), column_alias_lookup=layer.configuration. get('column_alias_lookup', None), ) if layer.configuration else dict())) # if the the layer configuration doesn't exist, utilize the default layer configuration else: client_layer_configuration = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) geometry_type = config_entity.db_entity_by_key( db_entity_key).geometry_type layer_configuration = copy.copy( list( client_layer_configuration.import_layer_configurations( geometry_type))[0]) # Update the template LayerConfiguration to our db_entity_key layer_configuration.db_entity_key = db_entity_key return layer_configuration
def update_or_create_analysis_modules(config_entity, **kwargs): """ Creates a results library and Result instances upon saving a config_entity if they do not yet exist. :param config_entity :return: """ from footprint.client.configuration.fixture import AnalysisModuleFixture from footprint.client.configuration import resolve_fixture analysis_module_fixture = resolve_fixture("analysis_module", "analysis_module", AnalysisModuleFixture, config_entity.schema(), config_entity=config_entity) for analysis_module_configuration in analysis_module_fixture.default_analysis_module_configurations( ): # Create the table the first time analysis_module, created, updated = AnalysisModule.objects.update_or_create( config_entity=config_entity, key=analysis_module_configuration.key, defaults=dict( name=analysis_module_configuration.name, description=analysis_module_configuration.description, partner_description=analysis_module_configuration. partner_description, configuration=remove_keys( analysis_module_configuration.configuration, ['key', 'name', 'description']))) # Update the updater field to the user calling the module, or default to superadmin if not analysis_module.updater: analysis_module.updater = kwargs.get( 'user', get_user_model().objects.get(username=UserGroupKey.SUPERADMIN)) # For the first run make the creator the updater if not analysis_module.creator: analysis_module.creator = analysis_module.updater # update_or_create will kick off the run for updates. # don't let it run here previous = analysis_module._no_post_save_task_run analysis_module._no_post_save_task_run = True analysis_module.save() analysis_module._no_post_save_task_run = previous analysis_module.init()
def update_or_create_layer_style_from_configuration(config_entity, db_entity, layer, layer_configuration): """ Iterates through the LayerConfiguration and creates LayerStyle instances for each that contain default styling for the configured attributes :return: """ # Find the corresponding config_entity_fixture, or parent fixture if it doesn't exist layer_fixture = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) logger.info("Configuring Layer Media for %s. Processing Layer Configurations" % config_entity.full_name) logger.info("Config Entity %s. layer_configuration %s. layer %s" % (config_entity, layer_configuration.__dict__, layer)) layer_fixture.update_or_create_layer_style(config_entity, layer_configuration, layer)
def update_or_create_layer_library_and_layers(config_entity, **kwargs): # Create LayerLibrary instances based on each LayerLibrary configuration if the configuration's scope # matches that of config_entity client_layer_fixture = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) layer_library_configurations = FixtureList(client_layer_fixture.layer_libraries()).matching_scope( class_scope=config_entity.__class__ ) logger.info("Processing LayerLibrary Configurations %s" % ', '.join(map( lambda layer_library_configuration: layer_library_configuration.key, layer_library_configurations))) for layer_library_configuration in layer_library_configurations: _update_or_create_layer_library_and_layers(config_entity, layer_library_configuration, **kwargs)
def resolve_layer_configuration(config_entity, db_entity_key, layer): """ Creates a LayerConfiguration for imported layers using the template LayerConfigurations designed in the LayerConfigurationFixture.import_layer_configurations """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture # if a layer exists and it has a layer configuration update it if layer and layer.configuration: layer_configuration = LayerConfiguration( **merge( dict( db_entity_key=layer.db_entity_key, layer_library_key=layer.key, visible=layer.visible, # Convert the LayerStyle to a dict, which is what a LayerConfiguration expects, and wipe out the ids layer_style=model_dict(layer.medium) ), dict( built_form_set_key=layer.configuration.get('built_form_key', None), sort_priority=layer.configuration.get('sort_priority', None), attribute_sort_priority=layer.configuration.get('attribute_sort_priority', None), column_alias_lookup=layer.configuration.get('column_alias_lookup', None), ) if layer.configuration else dict() ) ) # if the the layer configuration doesn't exist, utilize the default layer configuration else: client_layer_configuration = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) geometry_type = config_entity.db_entity_by_key(db_entity_key).geometry_type layer_configuration = copy.copy(list(client_layer_configuration.import_layer_configurations(geometry_type))[0]) # Update the template LayerConfiguration to our db_entity_key layer_configuration.db_entity_key = db_entity_key return layer_configuration
def update_or_create_layer_library_and_layers(config_entity, **kwargs): # Create LayerLibrary instances based on each LayerLibrary configuration if the configuration's scope # matches that of config_entity client_layer_fixture = resolve_fixture("presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) layer_library_configurations = FixtureList( client_layer_fixture.layer_libraries()).matching_scope( class_scope=config_entity.__class__) logger.info("Processing LayerLibrary Configurations %s" % ', '.join( map( lambda layer_library_configuration: layer_library_configuration. key, layer_library_configurations))) for layer_library_configuration in layer_library_configurations: _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, **kwargs)
def on_layer_post_save_process_layer(sender, **kwargs): """ For layer create/update/clone, this updates the saved layer """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture layer = InstanceBundle.extract_single_instance(**kwargs) logger.info("Handler: No Post Save Publising %s" % layer._no_post_save_publishing) if layer._no_post_save_publishing: return db_entity_interest = layer.db_entity_interest db_entity = db_entity_interest.db_entity config_entity = db_entity_interest.config_entity.subclassed logger.info( "Handler: Layer Publishing. on_layer_post_save_process_layer %s for config entity %s and db_entity %s" % (layer.full_name, config_entity.name, db_entity.key)) layer_configuration_fixture = resolve_fixture("presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) # Update the layer via the layer library update_or_create # Find LayerLibraries matching the ConfigEntity class schope for layer_library_configuration in layer_configuration_fixture.layer_libraries( ): logger.info("Handler: Layer Configuration: %s" % layer_library_configuration) # Update/Create the layer library and layers _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, db_entity_keys=[db_entity.key])
def update_or_create_analysis_modules(config_entity, **kwargs): """ Creates a results library and Result instances upon saving a config_entity if they do not yet exist. :param config_entity :return: """ from footprint.client.configuration.fixture import AnalysisModuleFixture from footprint.client.configuration import resolve_fixture analysis_module_fixture = resolve_fixture( "analysis_module", "analysis_module", AnalysisModuleFixture, config_entity.schema(), config_entity=config_entity) for analysis_module_configuration in analysis_module_fixture.default_analysis_module_configurations(): # Create the table the first time analysis_module, created, updated = AnalysisModule.objects.update_or_create( config_entity=config_entity, key=analysis_module_configuration.key, defaults=dict( name=analysis_module_configuration.name, description=analysis_module_configuration.description, partner_description=analysis_module_configuration.partner_description, configuration=remove_keys(analysis_module_configuration.configuration, ['key', 'name', 'description'])) ) # Update the updater field to the user calling the module, or default to superadmin if not analysis_module.updater: analysis_module.updater = kwargs.get('user', get_user_model().objects.get(username=UserGroupKey.SUPERADMIN)) # For the first run make the creator the updater if not analysis_module.creator: analysis_module.creator = analysis_module.updater # update_or_create will kick off the run for updates. # don't let it run here previous = analysis_module._no_post_save_task_run analysis_module._no_post_save_task_run = True analysis_module.save() analysis_module._no_post_save_task_run = previous analysis_module.init()
def on_layer_post_save_process_layer(sender, **kwargs): """ For layer create/update/clone, this updates the saved layer """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture layer = InstanceBundle.extract_single_instance(**kwargs) logger.info("Handler: No Post Save Publising %s" % layer._no_post_save_publishing) if layer._no_post_save_publishing: return db_entity_interest = layer.db_entity_interest db_entity = db_entity_interest.db_entity config_entity = db_entity_interest.config_entity.subclassed logger.info("Handler: Layer Publishing. on_layer_post_save_process_layer %s for config entity %s and db_entity %s" % (layer.full_name, config_entity.name, db_entity.key)) layer_configuration_fixture = resolve_fixture( "presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) # Update the layer via the layer library update_or_create # Find LayerLibraries matching the ConfigEntity class schope for layer_library_configuration in layer_configuration_fixture.layer_libraries(): logger.info("Handler: Layer Configuration: %s" % layer_library_configuration) # Update/Create the layer library and layers _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, db_entity_keys=[db_entity.key])
def on_layer_post_save_db_entity_process_layer(sender, **kwargs): """ For db_entity create/update/clone, this creates or updates the layer """ from footprint.client.configuration.fixture import LayerConfigurationFixture from footprint.client.configuration.utils import resolve_fixture db_entity_interest = InstanceBundle.extract_single_instance(**kwargs) config_entity = db_entity_interest.config_entity.subclassed db_entity = db_entity_interest.db_entity logger.info( "Handler: on_layer_post_save_db_enitty_process_layer for DbEntity: key %s, id %s" % (db_entity.key, db_entity.id)) # Return if the db_entity was not created from an user imported feature # Configured layer saving is handled by after saving the ConfigEntity if not db_entity.feature_class_configuration.generated: return layer_configuration_fixture = resolve_fixture("presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) # Update the layer via the layer library update_or_create # Find LayerLibraries matching the ConfigEntity class schope for layer_library_configuration in layer_configuration_fixture.layer_libraries( ): logger.info("Handler: Layer Library Configuration: %s" % layer_library_configuration) # Update/Create the layer library and layers _update_or_create_layer_library_and_layers( config_entity, layer_library_configuration, db_entity_keys=[db_entity.key])
def update_or_create_layer_style_from_configuration(config_entity, db_entity, layer, layer_configuration): """ Iterates through the LayerConfiguration and creates LayerStyle instances for each that contain default styling for the configured attributes :return: """ # Find the corresponding config_entity_fixture, or parent fixture if it doesn't exist layer_fixture = resolve_fixture("presentation", "layer", LayerConfigurationFixture, config_entity.schema(), config_entity=config_entity) logger.info( "Configuring Layer Media for %s. Processing Layer Configurations" % config_entity.full_name) logger.info("Config Entity %s. layer_configuration %s. layer %s" % (config_entity, layer_configuration.__dict__, layer)) layer_fixture.update_or_create_layer_style(config_entity, layer_configuration, layer)
def update_or_create_behaviors(config_entity, **kwargs): """ Creates Behaviors when saving a config_entity if they do not yet exist. :param config_entity :return: """ # Just process Regions and GlobalConfig if not isinstance(config_entity, GlobalConfig, Region): return from footprint.client.configuration.fixture import BehaviorFixture client_behavior_fixture = resolve_fixture( "behavior", "behavior", BehaviorFixture, config_entity.schema(), config_entity=config_entity) # Create each ResultLibrary and store them as a dict keyed by their key result_library_lookup = map_to_dict(lambda result_library_config: [ result_library_config.key, ResultLibrary.objects.update_or_create( key=result_library_config.key, config_entity=config_entity, scope=config_entity.schema(), defaults=dict( name=result_library_config.name.format(config_entity.name), description=result_library_config.description.format(config_entity.name) ) )[0]], client_result.result_libraries()) #for key, result_library in result_library_lookup.items(): # result_library.results.all().delete() # Create each configured Result for result_config in filter(lambda result: not db_entity_keys or result.result_db_entity_key in db_entity_keys or result.source_db_entity_key in db_entity_keys, client_result.results()): logger.info("Result Publishing Result DbEntity Key: %s" % result_config.result_db_entity_key) # Create the db_entity and db_entity_interest for the result db_entity = result_config.update_or_create_db_entity(config_entity) # Make the db_entity the default selected one for its key previous = config_entity._no_post_save_publishing config_entity._no_post_save_publishing = True config_entity.save() config_entity._no_post_save_publishing = previous # Test the query db_entity.parse_query(config_entity) db_entity_interest = DbEntityInterest.objects.get( config_entity=config_entity, db_entity__key=result_config.result_db_entity_key ) # Create a result for each result key given. result, created, updated = Result.objects.update_or_create( db_enitty_interest=db_entity_interest, defaults=dict( # Use the Result's custom Medium, keyed by the Result key medium=result_config.resolve_result_medium(), configuration=result_config.get_presentation_medium_configuration()) ) # If created, add the result to the matching result library if created: result_library_lookup[result_config.result_library_key].presentation_media.add(result) # Remove orphan results and their DbEntityInterests/DbEntities result_library_ids = map(lambda result_library: result_library.id, ResultLibrary.objects.filter(config_entity=config_entity)) valid_result_keys = map(lambda result_config: result_config.result_db_entity_key, client_result.results()) orphan_results = Result.objects.filter(presentation__id__in=result_library_ids).exclude(db_entity_key__in=valid_result_keys) DbEntityInterest.objects.filter(config_entity=config_entity, db_entity__key__in=map(lambda result: result.db_entity_key, orphan_results)).delete() orphan_results.delete()