def _load_table_layers(self, config_collection):
"""
In order to use attribute tables in the composition, the
corresponding vector layers need to be added to the layer
registry. This method creates vector layers from the linked tables
in the configuration items. This is required prior to creating the
composition from file.
:param config_collection: Table configuration collection built from
the template file.
:type config_collection: TableConfigurationCollection
"""
table_configs = config_collection.items().values()
v_layers = []
for conf in table_configs:
layer_name = conf.linked_table()
v_layer = vector_layer(layer_name)
if v_layer is None:
return
if not v_layer.isValid():
return
v_layers.append(v_layer)
self._map_memory_layers.append(v_layer.id())
self.map_registry.addMapLayers(v_layers, False)
def vector_layer(self):
"""
Returns a QgsVectorLayer based on the configuration information
specified in the mapper including the system-wide data connection
properties.
"""
from stdm.data.pg_utils import vector_layer
if self._dbmodel is None:
msg = QApplication.translate("ForeignKeyMapper",
"Primary database model object not defined.")
return None, msg
filter_layer = vector_layer(self._entity.name)
if filter_layer is None:
msg = QApplication.translate("ForeignKeyMapper",
"Vector layer could not be constructed from the database table.")
return None, msg
if not filter_layer.isValid():
trans_msg = QApplication.translate("ForeignKeyMapper",
u"The vector layer for '{0}' table is invalid.")
msg = trans_msg.format(self._entity.name)
return None, msg
return filter_layer, ""
def _load_table_layers(self, config_collection):
"""
In order to use attribute tables in the composition, the
corresponding vector layers need to be added to the layer
registry. This method creates vector layers from the linked tables
in the configuration items. This is required prior to creating the
composition from file.
:param config_collection: Table configuration collection built from
the template file.
:type config_collection: TableConfigurationCollection
"""
table_configs = config_collection.items().values()
v_layers = []
for conf in table_configs:
layer_name = conf.linked_table()
v_layer = vector_layer(layer_name)
if v_layer is None:
return
if not v_layer.isValid():
return
v_layers.append(v_layer)
self._map_memory_layers.append(v_layer.id())
self.map_registry.addMapLayers(v_layers, False)
def set_table_vector_layer(self, table_name):
"""
Creates a vector layer and appends it to the composer table item.
:param table_name: Name of the linked table containing tabular
information.
:type table_name: str
"""
self._notif_bar.clear()
if not table_name:
return
v_layer = vector_layer(table_name)
if v_layer is None:
msg = QApplication.translate(
"ComposerTableDataSourceEditor",
"A vector layer could not be created from the table.")
self._notif_bar.insertErrorNotification(msg)
return
if not v_layer.isValid():
msg = QApplication.translate(
"ComposerTableDataSourceEditor",
"Invalid vector layer, the table will not be added.")
self._notif_bar.insertErrorNotification(msg)
return
#No need to add the layer in the legend
QgsMapLayerRegistry.instance().addMapLayer(v_layer, False)
self._composer_table_item.setVectorLayer(
v_layer) # _composer_table_item is QgsComposerAttributeTable
self._composer_table_item.update()
def load_table_layers(config_collection):
"""
In order to be able to use attribute tables in the composition, the
corresponding vector layers need to be added to the layer
registry. This method creates vector layers from the linked tables
in the configuration items. This is required prior to creating the
composition from file.
:param config_collection: Table configuration collection built from
the template file.
:type config_collection: TableConfigurationCollection
:returns: Valid layers that have been successfully added to the
registry.
:rtype: list
"""
#table_configs = list(config_collection.items()).values()
table_configs = config_collection.items()
v_layers = []
for conf in table_configs:
layer_name = conf.linked_table()
v_layer = vector_layer(layer_name)
if v_layer is None:
continue
if not v_layer.isValid():
continue
v_layers.append(v_layer)
QgsProject.instance().addMapLayers(v_layers, False)
return v_layers
def load_table_layers(config_collection):
"""
In order to be able to use attribute tables in the composition, the
corresponding vector layers need to be added to the layer
registry. This method creates vector layers from the linked tables
in the configuration items. This is required prior to creating the
composition from file.
:param config_collection: Table configuration collection built from
the template file.
:type config_collection: TableConfigurationCollection
:returns: Valid layers that have been successfully added to the
registry.
:rtype: list
"""
table_configs = config_collection.items().values()
v_layers = []
for conf in table_configs:
layer_name = conf.linked_table()
v_layer = vector_layer(layer_name)
if v_layer is None:
continue
if not v_layer.isValid():
continue
v_layers.append(v_layer)
QgsMapLayerRegistry.instance().addMapLayers(v_layers, False)
return v_layers
def vector_layer(self):
"""
Returns a QgsVectorLayer based on the configuration information
specified in the mapper including the system-wide data connection
properties.
"""
from stdm.data.pg_utils import vector_layer
if self._dbmodel is None:
msg = QApplication.translate(
"ForeignKeyMapper",
"Primary database model object not defined.")
return None, msg
filter_layer = vector_layer(self._entity.name)
if filter_layer is None:
msg = QApplication.translate(
"ForeignKeyMapper",
"Vector layer could not be constructed from the database table."
)
return None, msg
if not filter_layer.isValid():
trans_msg = QApplication.translate(
"ForeignKeyMapper",
"The vector layer for '{0}' table is invalid.")
msg = trans_msg.format(self._entity.name)
return None, msg
return filter_layer, ""
def __init__(self, search_config):
self._config = search_config
self._is_valid = self._validate_data_source()
self._geom_columns = []
self._valid_cols = OrderedDict()
self._valid_filter_cols = OrderedDict()
self._vector_layer = None
self._column_types = {}
# Set attributes if data source is valid
if self._is_valid:
self._geom_columns = table_column_names(self._config.data_source,
True)
self._valid_cols = self._validate_columns()
self._valid_filter_cols = self._validate_filter_columns()
# Use the first geometry column in the list. Hence, it is
# important to ensure that each data has not more than one
# geometry column.
geom_col = self._geom_columns[0] if len(
self._geom_columns) > 0 else ''
self._vector_layer = vector_layer(
self._config.data_source,
layer_name=self._config.display_name,
geom_column=geom_col)
def set_table_vector_layer(self, table_name):
"""
Creates a vector layer and appends it to the composer table item.
:param table_name: Name of the linked table containing tabular
information.
:type table_name: str
"""
self._notif_bar.clear()
if not table_name:
return
v_layer = vector_layer(table_name)
if v_layer is None:
msg = QApplication.translate("ComposerTableDataSourceEditor",
"A vector layer could not be created from the table.")
self._notif_bar.insertErrorNotification(msg)
return
if not v_layer.isValid():
msg = QApplication.translate("ComposerTableDataSourceEditor",
"Invalid vector layer, the table will not be added.")
self._notif_bar.insertErrorNotification(msg)
return
#No need to add the layer in the legend
QgsMapLayerRegistry.instance().addMapLayer(v_layer, False)
if len(self.composer_item().columns()) > 0:
self._composer_table_item.setVectorLayer(v_layer) # _composer_table_item is QgsComposerAttributeTable
self._composer_table_item.update()
def _refresh_map_canvas(self):
"""
Refresh map canvas on file source or feature type change
:return: None
:rtype: None
"""
curr_layer = vector_layer(self.sp_table, geom_column=self.sp_col)
layer_extent = curr_layer.extent()
gpx_view.remove_vertex(self.map_canvas, self.point_row_attr)
self.map_canvas.setExtent(layer_extent)
self.map_canvas.refresh()
def create_layer(self):
srid = None
column = ''
if self.entity.has_geometry_column():
geom_cols = [col.name for col in self.entity.columns.values()
if col.TYPE_INFO == 'GEOMETRY']
column = geom_cols[0]
geom_col_obj = self.entity.columns[column]
if geom_col_obj.srid >= 100000:
srid = geom_col_obj.srid
layer = vector_layer(self.entity.name, geom_column=column,
proj_wkt=srid)
return layer
def create_layer(self):
srid = None
column = ''
if self.entity.has_geometry_column():
geom_cols = [col.name for col in self.entity.columns.values()
if col.TYPE_INFO == 'GEOMETRY']
column = geom_cols[0]
geom_col_obj = self.entity.columns[column]
if geom_col_obj.srid >= 100000:
srid = geom_col_obj.srid
layer = vector_layer(self.entity.name, geom_column=column,
proj_wkt=srid)
return layer
def lht_plot_layer(scheme_id=-1, layer_name='Plot'):
"""
Creates the plot layer for the given scheme and sets the name to plot.
:param scheme_id: Primary key of the scheme for which the plots belong to
and loads all the plots within it. If -1 it loads all plots in the table.
:type scheme_id: int
:param layer_name: Name assigned to the layer containing the plots.
type: layer_name: str
"""
if scheme_id == -1:
sql = ''
else:
sql = 'scheme_id={0}'.format(scheme_id)
return vector_layer(table_name='cb_plot',
sql=sql,
key='',
geom_column='geom',
layer_name=layer_name)
def column_to_fk_layer_join(self, column, layer, join_field):
"""
Creates and executes the join by creating fk layer and running the join
method using a column object.
:param column: The column object
:type column: Object
:param layer: The layer to contain the joined fk layer
:type layer: QgsVectorLayer
:param join_field: The join field that is in the fk layer
:type join_field: String
"""
fk_entity = column.entity_relation.parent
fk_layer = vector_layer(fk_entity.name, layer_name=fk_entity.name)
QgsProject.instance().addMapLayer(fk_layer, False)
# hide the fk id column
column.hidden = True
header = column.header()
self.execute_layers_join(layer, column.name, header, fk_layer,
join_field)
def on_bt_save_clicked(self):
"""
Run when Qtablewidget button save is clicked
"""
geom_list = []
for key, vertex in self.vertex_dict.iteritems():
if vertex[3] == Qt.Checked:
geom_list.append(QgsPoint(vertex[1], vertex[2]))
if self.active_layer_geometry_typ == 0:
geom = QgsGeometry.fromPoint(geom_list[0])
elif self.active_layer_geometry_typ == 1:
geom = QgsGeometry.fromPolyline(geom_list)
elif self.active_layer_geometry_typ == 2:
geom = QgsGeometry.fromPolygon([geom_list])
geom_wkb = geom.exportToWkt()
non_sp_colms = non_spatial_table_columns(self.sp_table)
for key, vertex in self.vertex_dict.iteritems():
self.map_canvas.scene().removeItem(vertex[0])
self.close()
self.curr_layer = vector_layer(self.sp_table, geom_column=self.sp_col)
self.iface.mapCanvas().setExtent(self.curr_layer.extent())
self.iface.mapCanvas().refresh()
srid = self.entity.columns[self.sp_col].srid
#init form
editor = EntityEditorDialog(self.entity, None, self.iface.mainWindow())
model = editor.model()
# add geometry into the model
setattr(model, self.sp_col, 'SRID={};{}'.format(srid, geom_wkb))
editor.exec_()
def column_to_fk_layer_join(self, column, layer, join_field):
"""
Creates and executes the join by creating fk layer and running the join
method using a column object.
:param column: The column object
:type column: Object
:param layer: The layer to contain the joined fk layer
:type layer: QgsVectorLayer
:param join_field: The join field that is in the fk layer
:type join_field: String
"""
fk_entity = column.entity_relation.parent
fk_layer = vector_layer(
fk_entity.name,
layer_name=fk_entity.name
)
QgsMapLayerRegistry.instance().addMapLayer(
fk_layer, False
)
# hide the fk id column
column.hidden = True
header = column.header()
self.execute_layers_join(layer, column.name, header, fk_layer, join_field)
def on_add_to_canvas_button_clicked(self):
"""
Add STDM layer to map canvas.
"""
if self.stdm_layers_combo.count() == 0:
return
sp_col_info = self.stdm_layers_combo.itemData(
self.stdm_layers_combo.currentIndex())
if sp_col_info is None:
title = QApplication.translate('SpatialUnitManagerDockWidget',
'Spatial Unit Manager')
msg = QApplication.translate(
'SpatialUnitManagerDockWidget',
'Spatial Column Layer Could not be found')
# Message: Spatial column information
# could not be found
QMessageBox.warning(self.iface.mainWindow(), title, msg)
table_name, spatial_column = sp_col_info["table_name"], \
sp_col_info["column_name"]
# Check if the layer has already been
layer_item = sp_col_info.get('item', None)
layer_name = self.geom_col_layer_name(table_name, layer_item)
if layer_name in self._map_registry_layer_names():
layer = QgsProject.instance().mapLayersByName(layer_name)[0]
self.iface.setActiveLayer(layer)
return
self.curr_lyr_table = table_name
self.curr_lyr_sp_col = spatial_column
if layer_item is not None:
if isinstance(layer_item, str):
layer_name = layer_item
else:
layer_name = layer_item.layer_display()
entity = self._curr_profile.entity_by_name(table_name)
if entity is not None:
geom_col_obj = entity.columns[spatial_column]
srid = None
if geom_col_obj.srid >= 100000:
srid = geom_col_obj.srid
curr_layer = vector_layer(table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=srid)
else:
curr_layer = vector_layer(table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=None)
# for lookup layer.
else:
curr_layer = vector_layer(table_name, geom_column=spatial_column)
if curr_layer is not None and curr_layer.isValid():
if curr_layer.name() in self._map_registry_layer_names():
return
QgsProject.instance().addMapLayer(curr_layer)
LayerUtils.tag_layer_as_stdm_layer(curr_layer)
self.zoom_to_layer()
self.onLayerAdded.emit(spatial_column, curr_layer)
self.toggle_entity_multi_layers(curr_layer)
self.set_canvas_crs(curr_layer)
# Required in order for the layer name to be set
if layer_name is not None:
QTimer.singleShot(
100, lambda: self._set_layer_display_name(
curr_layer, layer_name))
entity = self._curr_profile.entity_by_name(self.curr_lyr_table)
fk_fields = self.join_fk_layer(curr_layer, entity)
if entity is not None:
self.sort_joined_columns(curr_layer, fk_fields)
self.set_field_alias(curr_layer, entity, fk_fields)
elif curr_layer is not None:
msg = QApplication.translate(
"Spatial Unit Manager",
"'{0}.{1}' layer is invalid, it cannot "
"be added to the map view.".format(table_name, spatial_column))
QMessageBox.critical(self.iface.mainWindow(),
'Spatial Unit Manager', msg)
def on_add_to_canvas_button_clicked(self):
"""
Add STDM layer to map canvas.
"""
if self.stdm_layers_combo.count() == 0:
return
sp_col_info = self.stdm_layers_combo.itemData(
self.stdm_layers_combo.currentIndex()
)
if sp_col_info is None:
title = QApplication.translate(
'SpatialUnitManagerDockWidget',
'Spatial Unit Manager'
)
msg = QApplication.translate(
'SpatialUnitManagerDockWidget',
'Spatial Column Layer Could not be found'
)
# Message: Spatial column information
# could not be found
QMessageBox.warning(self.iface.mainWindow(), title, msg)
table_name, spatial_column = sp_col_info["table_name"], \
sp_col_info["column_name"]
# Check if the layer has already been
layer_item = sp_col_info.get('item', None)
layer_name = self.geom_col_layer_name(
table_name, layer_item
)
if layer_name in self._map_registry_layer_names():
layer = QgsMapLayerRegistry.instance().mapLayersByName(layer_name)[0]
self.iface.setActiveLayer(layer)
return
self.curr_lyr_table = table_name
self.curr_lyr_sp_col = spatial_column
if not layer_item is None:
if isinstance(layer_item, str) or isinstance(layer_item, unicode):
layer_name = layer_item
else:
layer_name = layer_item.layer_display()
entity = self._curr_profile.entity_by_name(table_name)
if entity is not None:
geom_col_obj = entity.columns[spatial_column]
srid = None
if geom_col_obj.srid >= 100000:
srid = geom_col_obj.srid
curr_layer = vector_layer(
table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=srid
)
else:
curr_layer = vector_layer(
table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=None
)
# for lookup layer.
else:
curr_layer = vector_layer(
table_name, geom_column=spatial_column
)
if curr_layer.isValid():
if curr_layer.name() in self._map_registry_layer_names():
return
QgsMapLayerRegistry.instance().addMapLayer(
curr_layer
)
self.zoom_to_layer()
self.onLayerAdded.emit(spatial_column, curr_layer)
self.toggle_entity_multi_layers(curr_layer)
self.set_canvas_crs(curr_layer)
# Required in order for the layer name to be set
if layer_name is not None:
QTimer.singleShot(
100,
lambda: self._set_layer_display_name(
curr_layer,
layer_name
)
)
entity = self._curr_profile.entity_by_name(self.curr_lyr_table)
fk_fields = self.join_fk_layer(curr_layer, entity)
if entity is not None:
self.sort_joined_columns(curr_layer, fk_fields)
self.set_field_alias(curr_layer, entity, fk_fields)
else:
msg = QApplication.translate(
"Spatial Unit Manager",
"'{0}.{1}' layer is invalid, it cannot "
"be added to the map view.".format(
table_name, spatial_column
)
)
QMessageBox.critical(
self.iface.mainWindow(),
'Spatial Unit Manager',
msg
)
def on_add_to_canvas_button_clicked(self):
"""
Add STDM layer to map canvas.
"""
if self.stdm_layers_combo.count() == 0:
return
sp_col_info = self.stdm_layers_combo.itemData(
self.stdm_layers_combo.currentIndex())
if sp_col_info is None:
title = QApplication.translate('SpatialUnitManagerDockWidget',
'Spatial Unit Manager')
msg = QApplication.translate(
'SpatialUnitManagerDockWidget',
'Spatial Column Layer Could not be found')
# Message: Spatial column information
# could not be found
QMessageBox.warning(self.iface.mainWindow(), title, msg)
table_name, spatial_column = sp_col_info["table_name"], \
sp_col_info["column_name"]
# Check if the layer has already been
layer_item = sp_col_info.get('item', None)
layer_name = self.geom_col_layer_name(table_name, layer_item)
if layer_name in self._map_registry_layer_names():
return
# Used in gpx_table.py
self.curr_lyr_table = table_name
self.curr_lyr_sp_col = spatial_column
if not layer_item is None:
curr_layer = vector_layer(table_name,
geom_column=spatial_column,
layer_name=layer_item.layer_display())
else:
curr_layer = vector_layer(table_name, geom_column=spatial_column)
if curr_layer.isValid():
QgsMapLayerRegistry.instance().addMapLayer(curr_layer)
self.toggle_entity_multi_layers(curr_layer)
self.set_canvas_crs(curr_layer)
# Required in order for the layer name to be set
QTimer.singleShot(
100, lambda: self._set_layer_display_name(
curr_layer, layer_item.layer_display()))
self.zoom_to_layer()
self.onLayerAdded.emit(spatial_column, curr_layer)
else:
msg = QApplication.translate(
"Spatial Unit Manager",
"'{0}.{1}' layer is invalid, it cannot "
"be added to the map view.".format(table_name, spatial_column))
QMessageBox.critical(self.iface.mainWindow(),
'Spatial Unit Manager', msg)