def importer(self, config_entity, db_entity, **kwargs): """ Replaces the normal ImportProcessor importer with one to import a shapefile from disk """ user = db_entity.creator if InformationSchema.objects.table_exists(db_entity.schema, db_entity.table): # The table already exists. Skip the import an log a warning logger.warn("The target table for the layer selection import already exists. Skipping table import.") else: feature_class_creator = FeatureClassCreator(config_entity, db_entity) origin_feature_class_configuration = db_entity.origin_instance.feature_class_configuration # Create the new DbEntity FeatureClassConfiguration from the origin's. Pass in what has already been # created for the new feature_class_configuration. This should have things like generated=True feature_class_configuration = feature_class_creator.complete_or_create_feature_class_configuration( origin_feature_class_configuration, **merge(db_entity.feature_class_configuration.__dict__, dict(generated=True))) # Update the DbEntity feature_class_creator.update_db_entity(feature_class_configuration) if feature_class_configuration.source_from_origin_layer_selection and \ feature_class_configuration.origin_layer_id: # If desired, limit the layer clone to that of the source layer's current LayerSelection for the # User doing the update layer_selection_class = get_or_create_layer_selection_class_for_layer( Layer.objects.get(id=feature_class_configuration.origin_layer_id), True) layer_selection = layer_selection_class.objects.get(user=user) features = layer_selection.selected_features else: # Leave blank to copy all features by default features = None DefaultImportProcessor().peer_importer(config_entity, db_entity, import_from_origin=True, source_queryset=features)
def db_entity_defaults(db_entity, config_entity=None): # Instantiate a FeatureClassCreator to make the FeatureClassConfiguration feature_class_creator = FeatureClassCreator(config_entity, db_entity, no_ensure=True) if config_entity: # Find the database of the configured client connection = resolve_fixture(None, "init", InitFixture, config_entity.schema()).import_database() # Remove the _test suffix when running unit tests. Until we can auto-population the _test version # of the database, we want to simply rely on the manually configured source database if connection: connection['database'] = connection['database'].replace( 'test_', '') else: # No config_entity abstract DbEntity case connection = None return dict( # The name is passed in or the titleized version of key name=db_entity.name or titleize(db_entity.key), # Postgres URL for local sources, or possibly a remote url (e.g. for background layer sources) # Unless overridden, create the url according to this postgres url scheme url=db_entity.url or \ ('postgres://{user}:{password}/{host}:{port}/{database}'.format( **merge(dict(port=5432), connection)) if connection else None), # Normally Equals the key, except for views of the table, like a Result DbEntity # Views leave this null and rely on query table=db_entity.table or (db_entity.key if not db_entity.query else None), # Query to create a "view" of the underlying data. Used by Result DbEntity instances query=db_entity.query, # How to group the features or query results. Not yet well hashed out group_by=db_entity.group_by, # The source DbEntity key if this DbEntity resulted from cloning a peer DbEntity source_db_entity_key=db_entity.source_db_entity_key, # Array used by remote data sources whose URLs have different host names # If so then the url will have a string variable for the host hosts=db_entity.hosts, # The User who created the DbEntity. TODO. Default should be an admin creator=db_entity.creator if hasattr(db_entity, 'creator') else get_user_model().objects.filter()[0], # The User who updated the DbEntity. TODO. Default should be an admin updater=db_entity.creator if hasattr(db_entity, 'creator') else get_user_model().objects.filter()[0], # The SRID of the Feature table srid=db_entity.srid, # This is a non-model object. So it is saved as a PickledObjectField # Whether the same instance is returned or not does not matter # If db_entity.feature_class_configuration is None, it will return None feature_class_configuration=feature_class_creator.complete_or_create_feature_class_configuration( db_entity.feature_class_configuration ), no_feature_class_configuration=db_entity.no_feature_class_configuration # feature_behavior is handled internally by DbEntity )
def db_entity_defaults(db_entity, config_entity=None): # Instantiate a FeatureClassCreator to make the FeatureClassConfiguration feature_class_creator = FeatureClassCreator(config_entity, db_entity, no_ensure=True) if config_entity: # Find the database of the configured client connection = resolve_fixture(None, "init", InitFixture, config_entity.schema()).import_database() # Remove the _test suffix when running unit tests. Until we can auto-population the _test version # of the database, we want to simply rely on the manually configured source database if connection: connection['database'] = connection['database'].replace('test_', '') else: # No config_entity abstract DbEntity case connection = None return dict( # The name is passed in or the titleized version of key name=db_entity.name or titleize(db_entity.key), # Postgres URL for local sources, or possibly a remote url (e.g. for background layer sources) # Unless overridden, create the url according to this postgres url scheme url=db_entity.url or \ ('postgres://{user}:{password}/{host}:{port}/{database}'.format( **merge(dict(port=5432), connection)) if connection else None), # Normally Equals the key, except for views of the table, like a Result DbEntity # Views leave this null and rely on query table=db_entity.table or (db_entity.key if not db_entity.query else None), # Query to create a "view" of the underlying data. Used by Result DbEntity instances query=db_entity.query, # How to group the features or query results. Not yet well hashed out group_by=db_entity.group_by, # The source DbEntity key if this DbEntity resulted from cloning a peer DbEntity source_db_entity_key=db_entity.source_db_entity_key, # Array used by remote data sources whose URLs have different host names # If so then the url will have a string variable for the host hosts=db_entity.hosts, # The User who created the DbEntity. TODO. Default should be an admin creator=db_entity.creator if hasattr(db_entity, 'creator') else get_user_model().objects.filter()[0], # The User who updated the DbEntity. TODO. Default should be an admin updater=db_entity.creator if hasattr(db_entity, 'creator') else get_user_model().objects.filter()[0], # The SRID of the Feature table srid=db_entity.srid, # This is a non-model object. So it is saved as a PickledObjectField # Whether the same instance is returned or not does not matter # If db_entity.feature_class_configuration is None, it will return None feature_class_configuration=feature_class_creator.complete_or_create_feature_class_configuration( db_entity.feature_class_configuration ), no_feature_class_configuration=db_entity.no_feature_class_configuration # feature_behavior is handled internally by DbEntity )