def setUp(self):
self.keyword_io = KeywordIO()
# SQLite Layer
uri = QgsDataSourceURI()
sqlite_building_path = test_data_path('exposure', 'exposure.sqlite')
uri.setDatabase(sqlite_building_path)
uri.setDataSource('', 'buildings_osm_4326', 'Geometry')
self.sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings',
'spatialite')
self.expected_sqlite_keywords = {
'category': 'exposure',
'datatype': 'OSM',
'subcategory': 'building'
}
# Raster Layer keywords
hazard_path = test_data_path('hazard', 'padang_tsunami_mw8.tif')
self.raster_layer, _ = load_layer(hazard_path)
self.expected_raster_keywords = {
'category': 'hazard',
'subcategory': 'tsunami',
'unit': 'm',
'title': 'A tsunami in Padang (Mw 8.8)'
}
# Vector Layer keywords
vector_path = test_data_path('exposure', 'buildings_osm_4326.shp')
self.vector_layer, _ = load_layer(vector_path)
self.expected_vector_keywords = {
'category': 'exposure',
'datatype': 'osm',
'subcategory': 'structure',
'title': 'buildings_osm_4326',
'purpose': 'dki'
}
# Keyword less layer
keywordless_path = test_data_path('other', 'keywordless_layer.shp')
self.keywordless_layer, _ = load_layer(keywordless_path)
def copy(self, target_path, keep_existent=False):
"""
Copy a layer to a new path and adjust its datasource.
:param layer: The layer to copy
:param target_path: A path to a folder into which the data will be copied
:param keep_existent: if True and target file already exists, keep it as it is
"""
if not self.is_file:
# Copy will also be called on non-file layers like WMS. In this case, just do nothing.
return
# Shapefiles... have the path in the source
file_path = self.layer.source()
# Spatialite have the path in the table part of the uri
uri = QgsDataSourceURI(self.layer.dataProvider().dataSourceUri())
if os.path.isfile(file_path):
source_path, file_name = os.path.split(file_path)
basename, extensions = get_file_extension_group(file_name)
for ext in extensions:
dest_file = os.path.join(target_path, basename + ext)
if os.path.exists(os.path.join(source_path, basename + ext)) and \
(keep_existent is False or not os.path.isfile(dest_file)):
shutil.copy(os.path.join(source_path, basename + ext), dest_file)
self._change_data_source(os.path.join(target_path, file_name))
# Spatialite files have a uri
else:
file_path = uri.database()
if os.path.isfile(file_path):
source_path, file_name = os.path.split(file_path)
basename, extensions = get_file_extension_group(file_name)
for ext in extensions:
dest_file = os.path.join(target_path, basename + ext)
if os.path.exists(os.path.join(source_path, basename + ext)) and \
(keep_existent is False or not os.path.isfile(dest_file)):
shutil.copy(os.path.join(source_path, basename + ext),
dest_file)
uri.setDatabase(os.path.join(target_path, file_name))
self._change_data_source(uri.uri())
def loadFeatureLayer(cls, table, chk=False):
if chk and cls._MapRegistry.mapLayersByName(table):
return
uri = QgsDataSourceURI()
uri.setDatabase(cls._PalFeaturesDb)
uri.setDataSource('', table, 'geometry')
vlayer = QgsVectorLayer(uri.uri(), table, 'spatialite')
# .qml should contain only style for symbology
vlayer.loadNamedStyle(os.path.join(cls._PalDataDir,
'{0}.qml'.format(table)))
# qDebug('render_lyr = {0}'.format(repr(vlayer)))
cls._MapRegistry.addMapLayer(vlayer)
# place new layer on top of render stack
render_lyrs = [vlayer.id()]
render_lyrs.extend(cls._MapSettings.layers())
# qDebug('render_lyrs = {0}'.format(repr(render_lyrs)))
cls._MapSettings.setLayers(render_lyrs)
# zoom to aoi
cls._MapSettings.setExtent(cls.aoiExtent())
cls._Canvas.zoomToFullExtent()
return vlayer
def prepareExecution(self,
cl,
geometryColumn='geom',
selectedFeatures=False):
"""
Prepare the process to be executed
cl: table name
"""
# loading layer prior to execution
lyr = self.loadLayerBeforeValidationProcess(cl)
# getting keyColumn because we want to be generic
uri = QgsDataSourceURI(lyr.dataProvider().dataSourceUri())
keyColumn = uri.keyColumn()
#getting feature map including the edit buffer
featureMap = self.mapInputLayer(lyr, selectedFeatures=selectedFeatures)
#getting table name with schema
if isinstance(cl, dict):
tableSchema = cl['tableSchema']
tableName = cl['tableName']
geometryColumn = cl['geom']
fullTableName = '''{0}.{1}'''.format(cl['tableSchema'],
cl['tableName'])
else:
fullTableName = cl
tableSchema, tableName = cl.split('.')
#setting temp table name
processTableName = fullTableName + '_temp'
# specific EPSG search
parameters = {
'tableSchema': tableSchema,
'tableName': tableName,
'geometryColumn': geometryColumn
}
srid = self.abstractDb.findEPSG(parameters=parameters)
#creating temp table
self.abstractDb.createAndPopulateTempTableFromMap(
fullTableName, featureMap, geometryColumn, keyColumn, srid)
return processTableName, lyr, keyColumn
def _load_layers(self):
"""Manually load all the layers for our project.
:return: A list of QgsMapLayer instances.
:rtype: list
"""
layers = []
# First the RW layer
host = 'db'
port = '5432'
user = '******'
password = '******'
dbname = 'gis'
uri = QgsDataSourceURI()
uri.setConnection(host, port, dbname, user, password)
schema = 'public'
table = 'flood_mapper_rw'
geometry_column = 'geometry'
where_clause = ''
title = 'RW'
uri.setDataSource(schema, table, geometry_column, where_clause)
layer = QgsVectorLayer(uri.uri(), title, 'postgres')
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
canvas_layer = QgsMapCanvasLayer(layer)
layers.append(canvas_layer)
# Now the JK layer
path = './data/jk.shp'
title = 'JK'
layer = QgsVectorLayer(path, title, 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
canvas_layer = QgsMapCanvasLayer(layer)
layers.append(canvas_layer)
return layers
def normalize_uri(self, layer):
"""Normalize URI from layer source. URI can be in a form
of QgsDataSourceURI which is related to RDBMS source or
general URI like CSV URI
:param layer : A layer
:type layer : QgsMapLayer
:return: normalized URI to be hashed
:raise: AttributeError if providerType not recognized
"""
# there are different method to extract unique uri based on
# layer type
try:
provider_type = str(layer.providerType())
except AttributeError:
raise UnsupportedProviderError(
'Could not determine type for provider: %s' %
layer.__class__.__name__)
source = layer.source()
if provider_type == 'postgres':
# Use QgsDataSourceURI to parse RDBMS datasource
# create unique uri based on host, schema, and tablename
datasource_uri = QgsDataSourceURI(source)
normalized_uri = ':'.join([
datasource_uri.host(),
datasource_uri.schema(),
datasource_uri.table()])
elif provider_type == 'delimitedtext':
# Use urlparse to parse delimitedtext uri
# create unique uri based on protocol, host, and path
general_uri = urlparse(source)
normalized_uri = ':'.join([
general_uri.scheme,
general_uri.netloc,
general_uri.path])
else:
normalized_uri = source
return normalized_uri
def getDataSources(self):
"""
Obtains the available databases from the layers loaded in the TOC
"""
self.dbCombo.clear()
self.dbCombo.addItem(self.tr("select a database"))
if self.databases:
self.databases.clear()
#dictionary of names and datasourceUri
self.databases = dict()
self.layers = self.iface.mapCanvas().layers()
for layer in self.layers:
dataSourceUri = QgsDataSourceURI(
layer.dataProvider().dataSourceUri())
dbName = dataSourceUri.database()
if dbName not in self.databases.keys():
self.databases[dbName] = (dataSourceUri,
self.getUserCredentials(layer))
#populating the combo
self.dbCombo.addItem(dbName)
def writeScriptIncludes(layers, json, matchCRS):
geojsonVars = ""
wfsVars = ""
styleVars = ""
for count, (layer, encode2json) in enumerate(zip(layers, json)):
vts = layer.customProperty("VectorTilesReader/vector_tile_url")
sln = safeName(layer.name()) + "_" + unicode(count)
if layer.type() == layer.VectorLayer:
if layer.providerType() != "WFS" or encode2json:
if vts is None:
geojsonVars += ('<script src="layers/%s"></script>' %
(sln + ".js"))
else:
layerSource = layer.source()
if ("retrictToRequestBBOX" in layerSource
or "restrictToRequestBBOX" in layerSource):
provider = layer.dataProvider()
uri = QgsDataSourceURI(provider.dataSourceUri())
wfsURL = uri.param("url")
wfsTypename = uri.param("typename")
wfsSRS = uri.param("srsname")
layerSource = wfsURL
layerSource += "?SERVICE=WFS&VERSION=1.0.0&"
layerSource += "REQUEST=GetFeature&TYPENAME="
layerSource += wfsTypename
layerSource += "&SRSNAME="
layerSource += wfsSRS
if not matchCRS:
layerSource = re.sub(r'SRSNAME\=EPSG\:\d+',
'SRSNAME=EPSG:3857', layerSource)
layerSource += "&outputFormat=text%2Fjavascript&"
layerSource += "format_options=callback%3A"
layerSource += "get" + sln + "Json"
wfsVars += ('<script src="%s"></script>' % layerSource)
if vts is not None:
sln = safeName(vts)
styleVars += ('<script src="styles/%s_style.js">'
'</script>' % sln)
return (geojsonVars, wfsVars, styleVars)
def __load_sensor_to_qgis(self):
# Create a vector layer loading data from freewat_sensor table (sqlite db)
layer = QgsMapLayerRegistry.instance().mapLayersByName(
config.oat_layer_name)
db_path = self.db.get_db_path()
if not db_path:
return
if len(layer) > 0:
self.sensor_layer = layer[0]
return
if not self.sensor_layer:
sql = "SELECT * FROM sqlite_master WHERE name ='freewat_sensors' and type='table'; "
res = self.db.execute_query(sql)
if len(res) == 0:
return
uri = QgsDataSourceURI()
uri.setDatabase(self.db.get_db_path())
schema = ''
table = 'freewat_sensors'
geom_column = 'geom'
uri.setDataSource(schema, table, geom_column)
display_name = config.oat_layer_name
# create QGIS layer
self.sensor_layer = QgsVectorLayer(uri.uri(), display_name,
'spatialite')
QgsMapLayerRegistry.instance().addMapLayer(self.sensor_layer)
def checkSelection(self):
toolname = "TopologicEdit"
# check that a layer is selected
layer = self.iface.mapCanvas().currentLayer()
if not layer:
QMessageBox.information(None, toolname, "A layer must be selected")
return
# check that the selected layer is a postgis one
if layer.providerType() != 'postgres':
QMessageBox.information(None, toolname, "A PostGIS layer must be selected")
return
uri = QgsDataSourceURI( layer.source() )
# get the layer schema
schema = str(uri.schema())
if not schema:
QMessageBox.information(None, toolname, "Selected layer must be a table, not a view\n"
"(no schema set in datasource " + str(uri.uri()) + ")")
return
# get the layer table
table = str(uri.table())
if not table:
QMessageBox.information(None, toolname, "Selected layer must be a table, not a view\n"
"(no table set in datasource)")
return
# get the selected features
selected = layer.selectedFeatures()
if not selected:
QMessageBox.information(None, toolname, "Select a point object to highlight topological connected line object(s)")
return
return selected
def set_connection(self, databaseidx, dbname=None):
"""
Connect to selected postgresql database
"""
selected = self.combo_database.itemText(databaseidx) or dbname
if not selected:
return
settings = QSettings()
settings.beginGroup("/PostgreSQL/connections/{}".format(selected))
if not settings.contains("database"):
# no entry?
QMessageBox.critical(self, "Error", "There is no defined database connection")
return
uri = QgsDataSourceURI()
settingsList = ["service", "host", "port", "database", "username", "password"]
service, host, port, database, username, password = map(
lambda x: settings.value(x, "", type=str), settingsList)
useEstimatedMetadata = settings.value("estimatedMetadata", False, type=bool)
sslmode = settings.value("sslmode", QgsDataSourceURI.SSLprefer, type=int)
settings.endGroup()
if service:
uri.setConnection(service, database, username, password, sslmode)
else:
uri.setConnection(host, port, database, username, password, sslmode)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
# connect to db
self.connect_to_uri(uri)
# update schema list
self.update_schema_list()
def populateSchemas(self):
if self.childCount() != 0:
return
settings = QSettings()
connSettings = '/PostgreSQL/connections/' + self.connection
database = settings.value(connSettings + '/database')
user = settings.value(connSettings + '/username')
host = settings.value(connSettings + '/host')
port = settings.value(connSettings + '/port')
passwd = settings.value(connSettings + '/password')
uri = QgsDataSourceURI()
uri.setConnection(host, str(port), database, user, passwd)
connInfo = uri.connectionInfo()
(success, user, passwd) = QgsCredentials.instance().get(connInfo, None, None)
if success:
QgsCredentials.instance().put(connInfo, user, passwd)
geodb = GeoDB(host, int(port), database, user, passwd)
schemas = geodb.list_schemas()
for oid, name, owner, perms in schemas:
item = QTreeWidgetItem()
item.setText(0, name)
item.setIcon(0, self.schemaIcon)
self.addChild(item)
def popSchemas(self):
self.schemaCombo.clear()
schemas = []
selected_db = self.getSelectedDb()
if len(self.getSelectedDb()) > 1:
try:
print 'tries'
uri = QgsDataSourceURI()
db_info = self.available_dbs[selected_db]
print db_info, selected_db
conname = selected_db
dbname = db_info['database']
user = db_info['username']
host = db_info['host']
port = db_info['port']
password = db_info['password']
uri.setConnection(host, port, dbname, user, password)
connstring = "dbname=%s user=%s host=%s port=%s password=%s" % (dbname, user, host, port, password)
schemas = getPostgisSchemas(connstring)
except:
print 'error'
pass
self.schemaCombo.addItems(schemas)
def __init__(self, parent=None):
"""Constructor."""
super(AirviroOfflineEdbDockWidget, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.create_db_lineedit.clear()
self.create_db_browse_btn.clicked.connect(self.select_save_db_filename)
self.open_db_lineedit.clear()
self.open_db_browse_btn.clicked.connect(self.select_open_db_filename)
self.open_edb_btn.clicked.connect(self.open_db)
self.db_uri = QgsDataSourceURI()
self.con = None
self.cur = None
self.epsg = None
self.layers = {}
def getUserCredentials(self, lyr):
"""
Gets user credentials to acess the database
"""
dataSourceUri = QgsDataSourceURI(lyr.dataProvider().dataSourceUri())
if dataSourceUri.host() == '':
return (None, None)
if dataSourceUri.password() != '':
return (dataSourceUri.username(), dataSourceUri.password())
connInfo = dataSourceUri.connectionInfo()
(success, user,
passwd) = QgsCredentials.instance().get(connInfo,
dataSourceUri.username(),
None)
# Put the credentials back (for yourself and the provider), as QGIS removes it when you "get" it
if success:
QgsCredentials.instance().put(connInfo, user, passwd)
else:
return (None, None)
return (user, passwd)
def __onDstOk(self):
"""
When the Ok button in Duplicate Distance Dialog is pushed
"""
self.__onDstPreview()
self.__dstDlg.accept()
geometry = QgsGeometry(self.__newFeature)
if not geometry.isGeosValid():
self.__iface.messageBar().pushMessage(QCoreApplication.translate("VDLTools", "Geos geometry problem"),
level=QgsMessageBar.CRITICAL, duration=0)
feature = QgsFeature(self.__layer.pendingFields())
feature.setGeometry(geometry)
primaryKey = QgsDataSourceURI(self.__layer.source()).keyColumn()
for field in self.__selectedFeature.fields():
if field.name() != primaryKey:
feature.setAttribute(field.name(), self.__selectedFeature.attribute(field.name()))
if len(self.__selectedFeature.fields()) > 0 and self.__layer.editFormConfig().suppress() != \
QgsEditFormConfig.SuppressOn:
self.__iface.openFeatureForm(self.__layer, feature)
else:
self.__layer.addFeature(feature)
# self.__layer.updateExtents()
self.__cancel()
def toMapLayer(self):
from qgis.core import QgsRasterLayer, QgsContrastEnhancement, QgsDataSourceURI, QgsCredentials
rl = QgsRasterLayer(self.gdalUri(), self.name)
if not rl.isValid():
err = rl.error().summary()
uri = QgsDataSourceURI(self.database().uri())
conninfo = uri.connectionInfo(False)
username = uri.username()
password = uri.password()
for i in range(3):
(ok, username, password) = QgsCredentials.instance().get(conninfo, username, password, err)
if ok:
uri.setUsername(username)
uri.setPassword(password)
rl = QgsRasterLayer(self.gdalUri(uri), self.name)
if rl.isValid():
break
if rl.isValid():
rl.setContrastEnhancement(QgsContrastEnhancement.StretchToMinimumMaximum)
return rl
def saveToPostGIS(self):
dlg = PostgisTableSelector(self, self.output.name.lower())
dlg.exec_()
if dlg.connection:
settings = QSettings()
mySettings = '/PostgreSQL/connections/' + dlg.connection
dbname = settings.value(mySettings + '/database')
user = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port')
password = settings.value(mySettings + '/password')
uri = QgsDataSourceURI()
uri.setConnection(host, str(port), dbname, user, password)
uri.setDataSource(
dlg.schema, dlg.table,
"the_geom" if self.output.hasGeometry() else None)
connInfo = uri.connectionInfo()
(success, user,
passwd) = QgsCredentials.instance().get(connInfo, None, None)
if success:
QgsCredentials.instance().put(connInfo, user, passwd)
self.leText.setText("postgis:" + uri.uri())
def saveToSpatialite(self):
fileFilter = self.output.tr('Spatialite files(*.sqlite)', 'OutputFile')
settings = QSettings()
if settings.contains('/Processing/LastOutputPath'):
path = settings.value('/Processing/LastOutputPath')
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value('/Processing/encoding', 'System')
fileDialog = QgsEncodingFileDialog(self, self.tr('Save Spatialite'),
path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = unicode(fileDialog.encoding())
self.output.encoding = encoding
fileName = unicode(files[0])
selectedFileFilter = unicode(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(
tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
settings.setValue('/Processing/LastOutputPath',
os.path.dirname(fileName))
settings.setValue('/Processing/encoding', encoding)
uri = QgsDataSourceURI()
uri.setDatabase(fileName)
uri.setDataSource(
'', self.output.name.lower(),
'the_geom' if self.output.hasGeometry() else None)
self.leText.setText("spatialite:" + uri.uri())
def getAttributesFromFeature(self, feature, layer, fieldNames=None):
"""
Retrieves the attributes from a given feature, except for their geometry and ID column values. If a list of
attributes is given, method will return those attributes if found. In case no attribute is found, None will
:param feature: (QgsFeature) feature from which attibutes will be retrieved.
:param layer: (QgsVectorLayer) layer containing target feature.
:param fieldNames: (list-of-str) list of field names to be exposed.
:return: (dict-of-object) attribute values for each attribute mapped.
"""
# fields to be ignored
ignoreList = []
if not fieldNames:
# retrieving key column name
uri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
keyColumn = uri.keyColumn()
# retrieving geometry column name
networLayerName = layer.name()
for key in self.networkClassesWithElemDict.keys():
if key.split(",")[1] in networLayerName:
geomColumn = key.split(",")[2]
break
# removing attributes that are calculated OTF
fieldNames = [
f for f in layer.fields()
if f.name() not in [keyColumn, geomColumn]
and '_otf' not in f.name()
]
else:
# check if all field names given are in fact fields for the layer
layerFields = layer.fields()
ignoreList = [
field for field in fieldNames if field not in layerFields
]
return {
field.name(): feature[field.name()]
for field in fieldNames if field not in ignoreList
}
def open_attribute_table(self):
"""
Open Qgis Attribute table
"""
if not self.oat:
return
if self.attr_layer:
self.clear_layout(self.editFrame.layout())
if self.attr_table:
self.attr_table.close()
del self.attr_table
self.attr_layer = None
uri = QgsDataSourceURI()
uri.setDatabase(config.db_path)
schema = ''
table = self.oat.name
uri.setDataSource(schema, table, '')
display_name = self.oat.name
# create layer from sqlite
self.attr_layer = QgsVectorLayer(uri.uri(), display_name, 'spatialite')
self.version = qgis.utils.QGis.QGIS_VERSION_INT
self.attr_table = self.iface.showAttributeTable(self.attr_layer)
# not working for Qgis 2.8 an 2.10
if self.version >= self.qgs_version:
# cast from QDialog to QWidget
self.attr_table.setWindowFlags(Qt.Widget)
# add table content to sensorManager Gui
self.editFrame.layout().addWidget(self.attr_table)
def make_vlayer(self, obj):
"""
Making layer from PostGIS table.
Args:
obj: Instance of a hydrodynamic model object class.
Returns:
QgsVectorLayer: QGIS Vector Layer object.
"""
vl_schema, vl_name = obj.schema, obj.name
try: # qgis2
uri = QgsDataSourceURI()
except: # qgis3
uri = QgsDataSourceUri()
uri.setConnection(self.host, self.port, self.dbname, self.user,
self.password)
if obj.geom_type is not None:
uri.setDataSource(vl_schema, vl_name, 'geom')
else:
uri.setDataSource(vl_schema, vl_name, None)
vlayer = QgsVectorLayer(uri.uri(), vl_name, 'postgres')
return vlayer
def load(self, layer, visible=True, collapsed_legend=False,
collapsed_group=True):
settings = QSettings("CatAIS", "VeriSO")
module_name = settings.value("project/appmodule")
provider = settings.value("project/provider")
db_host = settings.value("project/dbhost")
db_port = settings.value("project/dbport")
db_name = settings.value("project/dbname")
db_schema = settings.value("project/dbschema")
db_user = settings.value("project/dbuser")
db_pwd = settings.value("project/dbpwd")
db_admin = settings.value("project/dbadmin")
db_admin_pwd = settings.value("project/dbadminpwd")
epsg = settings.value("project/epsg")
if not db_schema:
self.message_bar.pushMessage("Error", tr(
"Missing database schema parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_host:
self.message_bar.pushMessage("Error", tr(
"Missing database host parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_name:
self.message_bar.pushMessage("Error", tr(
"Missing database name parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_port:
self.message_bar.pushMessage("Error", tr(
"Missing database port parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_user:
self.message_bar.pushMessage("Error", tr(
"Missing database user parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_pwd:
self.message_bar.pushMessage("Error", tr(
"Missing database user password parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_admin:
self.message_bar.pushMessage("Error", tr(
"Missing database administrator parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_admin_pwd:
self.message_bar.pushMessage("Error", tr(
"Missing database administrator password parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not provider:
self.message_bar.pushMessage("Error", tr(
"Missing provider parameter. Cannot load layer."),
QgsMessageBar.CRITICAL, duration=0)
return
if not module_name:
self.message_bar.pushMessage("Error", tr(
"Missing module name parameter. Cannot load layer."),
QgsMessageBar.CRITICAL, duration=0)
return
try:
# Postgres
if layer["type"] == "postgres":
featuretype = str(layer["featuretype"])
title = layer["title"]
key = str(layer["key"])
try:
readonly = (layer["readonly"])
except:
readonly = True
try:
geom = str(layer["geom"])
if geom == "":
geom = None
except:
geom = None
try:
style = str(layer["style"])
except:
style = ""
try:
group = str(layer["group"])
except:
group = None
try:
sql = str(layer["sql"])
except:
sql = ""
# Overwrite the active project settings/parameters to add
# *any* postgres layers.
try:
params = layer["params"]
provider = layer["type"]
db_host = params["dbhost"]
db_port = str(params["dbport"])
db_name = params["dbname"]
db_schema = params["dbschema"]
db_user = params["dbuser"]
db_pwd = params["dbpwd"]
db_admin = params["dbadmin"]
db_admin_pwd = params["dbadminpwd"]
except:
pass
uri = QgsDataSourceURI()
if readonly:
uri.setConnection(db_host, db_port, db_name, db_user,
db_pwd)
else:
uri.setConnection(db_host, db_port, db_name, db_admin,
db_admin_pwd)
uri.setDataSource(db_schema, featuretype, geom, sql, key)
my_layer = QgsVectorLayer(uri.uri(), title, provider)
# WMS / WMTS:
# WMTS is a bit ugly since we need to know the tileMatrixSet:
# Load layer manually in QGIS once an look for the tileMatrixSet
# in the layer properties.
elif layer["type"] in["wms", "wmts"]:
url = layer["url"]
title = layer["title"]
layers = layer["layers"]
format = layer["format"]
try:
tilematrixset = layer["tilematrixset"]
except:
tilematrixset = None
try:
crs = layer["crs"]
except:
crs = "EPSG:" + str(epsg)
try:
styles = layer["styles"]
except:
styles = ""
try:
group = layer["group"]
except:
group = None
try:
style = layer["style"]
except:
style = ""
my_layers = layers.split(",")
my_styles = styles.split(",")
layer_string = ""
style_string = ""
for my_layer in my_layers:
layer_string += "&layers=" + my_layer
# So werden einfach leere Styles requested.
# Korrekterweise wäre style=qml und wmsstyle = Style der
# vom WMS requested wird.
style_string += "&styles="
if layer["type"] == "wms":
uri = "IgnoreGetMapUrl=1&crs=" + crs + layer_string + \
style_string + "&format=" + format + "&url=" + url
else:
uri = "crs=" + crs + layer_string + style_string + \
"&format=" + format + "&tileMatrixSet=" + \
tilematrixset + "&url=" + url
my_layer = QgsRasterLayer(uri, title, "wms", False)
# local ogr and gdal formats
elif layer["type"] in ["gdal", "ogr"]:
title = layer["title"]
url = layer["url"]
try:
style = str(layer["style"])
except:
style = ""
try:
group = str(layer["group"])
except:
group = None
if layer["type"] == 'ogr':
my_layer = QgsVectorLayer(url, title, layer["type"])
else:
my_layer = QgsRasterLayer(url, title)
else:
self.message_bar.pushMessage(
"Error",
tr(
"Data provider not yet supported: ") + str(
layer["type"]), QgsMessageBar.CRITICAL,
duration=0)
return
if style != "":
if style.startswith('global_qml'):
qml_dir = "/plugins/veriso/"
else:
qml_dir = "/plugins/veriso/modules/%s/qml/" % \
module_name
"""qml_path = QDir.convertSeparators(QDir.cleanPath(
QgsApplication.qgisSettingsDirPath() +
qml_dir + style))"""
qml_path=QDir.convertSeparators(QDir.cleanPath(
(os.path.realpath(__file__)).split("plugins")[0] +qml_dir + style))
qml = QDir.convertSeparators(QDir.cleanPath(qml_path))
my_layer.loadNamedStyle(qml)
if not my_layer.isValid():
# str(title) throws some ascii out of range error...
self.message_bar.pushMessage("Error", title + tr(
" is not valid layer."), QgsMessageBar.CRITICAL,
duration=0)
return
else:
# QgsMapLayerRegistry.instance().addMapLayer(my_layer)
if group: # Layer soll in eine bestimmte Gruppe hinzugefügt
# werden.
QgsMapLayerRegistry.instance().addMapLayer(my_layer, False)
my_group_node = self.root.findGroup(group)
if not my_group_node: # Gruppe noch nicht vorhanden.
my_group_node = self.root.addGroup(group)
# Achtung: Das ist eher ein Workaround. Meines
# Erachtens hats noch einen Bug.
# Mit QgsMapLayerRegistry.instance().addMapLayer(
# my_layer, False) wird
# ein Layer noch nicht in die Legende gehängt.
# Anschliessend kann man ihn
# mit my_layer_node = self.root.addLayer(my_layer)
# der Legende hinzufügen.
# Das führt aber dazu, dass was mit dem MapCanvas
# nicht mehr stimmt, dh.
# .setExtent() funktioniert nicht mehr richtig. Wird
# der Layer jedoch direkt
# in die Legende gehängt, funktioniert .setExtent()
# tadellos. Jetzt wird halt
# momentan der Layer direkt eingehängt und
# anschliessend in die gewünschte
# Gruppe verschoben.
# Kleiner (positiver) Nebeneffekt: Der Layer ist
# defaultmässig ausgeschaltet.
#
# NEIN: Anscheinend ist es ein Problem wenn man dann
# layer_node.setVisible(Qt.Checked)
# macht. Dann funktionierts nicht mehr. -> Wieder
# zurückändern auf einfachere Methode.
# "Umweg": Hat Probleme gemacht, falls ein Gruppe
# "active" war. Dann wurden der neue
# Layer ebenfalls (zusätzlich) ihr hinzugefügt.
# print my_layer.id()
# my_layer_node = self.root.findLayer(
# my_layer.id())
# print my_layer_node
# cloned_layer = my_layer_node.clone()
# print cloned_layer
# my_group_node.insertChildNode(0,
# cloned_layer)
# self.root.removeChildNode(
# my_layer_node)
# my_layer_node = self.root.findLayer(
# my_layer.id()) # Layer bekommt neuen layer_node.
# "Direkt(er)"
my_layer_node = my_group_node.insertLayer(0, my_layer)
else:
QgsMapLayerRegistry.instance().addMapLayer(my_layer, False)
my_layer_node = self.root.addLayer(my_layer)
my_layer_node.setVisible(Qt.Unchecked)
my_layer_node.setCustomProperty("showFeatureCount",True)
if visible:
my_layer_node.setVisible(Qt.Checked)
if collapsed_legend:
my_layer_node.setExpanded(False)
else:
my_layer_node.setExpanded(True)
if 'my_group_node' in locals():
if collapsed_group:
my_group_node.setExpanded(False)
else:
my_group_node.setExpanded(True)
return my_layer
except Exception as e:
self.message_bar.pushMessage("Error", str(e),
QgsMessageBar.CRITICAL, duration=0)
QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL)
return
def __init__(self, iface, layer, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.layer = layer
uri = QgsDataSourceURI(layer.source())
dbplugin = None
db = None
if layer.dataProvider().name() == 'postgres':
dbplugin = createDbPlugin('postgis', 'postgres')
elif layer.dataProvider().name() == 'spatialite':
dbplugin = createDbPlugin('spatialite', 'spatialite')
elif layer.dataProvider().name() == 'oracle':
dbplugin = createDbPlugin('oracle', 'oracle')
elif layer.dataProvider().name() == 'virtual':
dbplugin = createDbPlugin('vlayers', 'virtual')
elif layer.dataProvider().name() == 'ogr':
dbplugin = createDbPlugin('gpkg', 'gpkg')
if dbplugin:
dbplugin.connectToUri(uri)
db = dbplugin.db
self.dbplugin = dbplugin
self.db = db
self.filter = ""
self.allowMultiColumnPk = isinstance(db, PGDatabase) # at the moment only PostgreSQL allows a primary key to span multiple columns, spatialite doesn't
self.aliasSubQuery = isinstance(db, PGDatabase) # only PostgreSQL requires subqueries to be aliases
self.setupUi(self)
self.setWindowTitle(
u"%s - %s [%s]" % (self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString()))
self.defaultLayerName = 'QueryLayer'
if self.allowMultiColumnPk:
self.uniqueColumnCheck.setText(self.trUtf8("Column(s) with unique values"))
else:
self.uniqueColumnCheck.setText(self.trUtf8("Column with unique values"))
self.editSql.setFocus()
self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.editSql.setMarginVisible(True)
self.initCompleter()
# allow copying results
copyAction = QAction("copy", self)
self.viewResult.addAction(copyAction)
copyAction.setShortcuts(QKeySequence.Copy)
copyAction.triggered.connect(self.copySelectedResults)
self.btnExecute.clicked.connect(self.executeSql)
self.btnSetFilter.clicked.connect(self.setFilter)
self.btnClear.clicked.connect(self.clearSql)
self.presetStore.clicked.connect(self.storePreset)
self.presetDelete.clicked.connect(self.deletePreset)
self.presetCombo.activated[str].connect(self.loadPreset)
self.presetCombo.activated[str].connect(self.presetName.setText)
self.updatePresetsCombobox()
self.geomCombo.setEditable(True)
self.geomCombo.lineEdit().setReadOnly(True)
self.uniqueCombo.setEditable(True)
self.uniqueCombo.lineEdit().setReadOnly(True)
self.uniqueModel = QStandardItemModel(self.uniqueCombo)
self.uniqueCombo.setModel(self.uniqueModel)
if self.allowMultiColumnPk:
self.uniqueCombo.setItemDelegate(QStyledItemDelegate())
self.uniqueModel.itemChanged.connect(self.uniqueChanged) # react to the (un)checking of an item
self.uniqueCombo.lineEdit().textChanged.connect(self.uniqueTextChanged) # there are other events that change the displayed text and some of them can not be caught directly
self.layerTypeWidget.hide() # show if load as raster is supported
#self.loadLayerBtn.clicked.connect(self.loadSqlLayer)
self.updateLayerBtn.clicked.connect(self.updateSqlLayer)
self.getColumnsBtn.clicked.connect(self.fillColumnCombos)
self.queryBuilderFirst = True
self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif"))
self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder)
self.presetName.textChanged.connect(self.nameChanged)
# Update from layer
# Fisrtly the SQL from QgsDataSourceURI table
sql = uri.table()
if uri.keyColumn() == '_uid_':
match = re.search('^\(SELECT .+ AS _uid_,\* FROM \((.*)\) AS _subq_.+_\s*\)$', sql, re.S)
if match:
sql = match.group(1)
else:
match = re.search('^\((SELECT .+ FROM .+)\)$', sql, re.S)
if match:
sql = match.group(1)
self.editSql.setText(sql)
self.executeSql()
# Then the columns
self.geomCombo.setCurrentIndex(self.geomCombo.findText(uri.geometryColumn(), Qt.MatchExactly))
if uri.keyColumn() != '_uid_':
self.uniqueColumnCheck.setCheckState(Qt.Checked)
if self.allowMultiColumnPk:
itemsData = uri.keyColumn().split(',')
for item in self.uniqueModel.findItems("*", Qt.MatchWildcard):
if item.data() in itemsData:
item.setCheckState(Qt.Checked)
else:
keyColumn = uri.keyColumn()
if self.uniqueModel.findItems(keyColumn):
self.uniqueCombo.setEditText(keyColumn)
# Finally layer name, filter and selectAtId
self.layerNameEdit.setText(layer.name())
self.filter = uri.sql()
if uri.selectAtIdDisabled():
self.avoidSelectById.setCheckState(Qt.Checked)
def onClickBtn3(self):
print('onClickBtn3')
global rbDict
if rbDict.has_key('QgsRubberBand'):
rbDict['QgsRubberBand'].reset(True)
# Network Analysis - https://docs.qgis.org/2.18/en/docs/pyqgis_developer_cookbook/network_analysis.html
selectedLayerIndex = "final_line"
self.iface.setActiveLayer(QgsMapLayerRegistry.instance().mapLayersByName( selectedLayerIndex )[0])
layer = self.iface.activeLayer()
vl = qgis.utils.iface.mapCanvas().currentLayer()
director = QgsLineVectorLayerDirector(vl, -1, '', '', '', 3)
properter = QgsDistanceArcProperter()
director.addProperter(properter)
crs = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # WGS 84
builder = QgsGraphBuilder(crs)
#find the point thing here
p1 = self.dlg.q3combo1.currentText()
p2 = self.dlg.q3combo2.currentText()
# Reuse the path to DB to set database name
uri = QgsDataSourceURI()
uri.setDatabase('F:/UTA/SEM 5/Adv DB/UTA_Final_DB/test.sqlite')
db = QSqlDatabase.addDatabase('QSPATIALITE');
db.setDatabaseName(uri.database())
# print(p1)
# print(p2)
if db.open():
query = db.exec_(" SELECT ST_AsText(geom), X(geom), Y(geom) FROM Final_point where name='{0}'".format(p1))
while query.next():
pStart = QgsPoint(query.record().value(1), query.record().value(2))
query = db.exec_(" SELECT ST_AsText(geom), X(geom), Y(geom) FROM Final_point where name='{0}'".format(p2))
while query.next():
pStop = QgsPoint(query.record().value(1), query.record().value(2))
pStart = QgsPoint(-97.12132313236886,32.73383913111192)
pStop = QgsPoint(-97.12127226228301,32.73252244190963)
tiedPoints = director.makeGraph(builder, [pStart, pStop])
print(tiedPoints)
graph = builder.graph()
tStart = tiedPoints[0]
tStop = tiedPoints[1]
idStart = graph.findVertex(tStart)
idStop = graph.findVertex(tStop)
(tree, cost) = QgsGraphAnalyzer.dijkstra(graph, idStart, 0)
if tree[idStop] == -1:
print("Path not found")
else:
p = []
curPos = idStop
while curPos != idStart:
p.append(graph.vertex(graph.arc(tree[curPos]).inVertex()).point())
curPos = graph.arc(tree[curPos]).outVertex();
p.append(tStart)
rb = QgsRubberBand(qgis.utils.iface.mapCanvas())
rb.setColor(QColor('purple'))
rb.setWidth(3)
rbDict['QgsRubberBand'] = rb
for pnt in p:
rb.addPoint(pnt)
def run(self):
layers = QgsMapLayerRegistry.instance().mapLayers().values()
layer_list = []
for layer in layers:
layer_list.append(layer.name())
print(layer_list)
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
self.dlg.qlkbtn1.clicked.connect(self.onClickBtn1)
self.dlg.qlkbtn2.clicked.connect(self.onClickBtn2)
self.dlg.qlkbtn3.clicked.connect(self.onClickBtn3)
# Reuse the path to DB to set database name
uri = QgsDataSourceURI()
uri.setDatabase('F:/UTA/SEM 5/Adv DB/UTA_Final_DB/test.sqlite')
db = QSqlDatabase.addDatabase('QSPATIALITE');
db.setDatabaseName(uri.database())
polygonNameList=[]
polygonTypeList = []
placemarksNameList = []
if db.open():
query = db.exec_(""" SELECT name FROM Final_poly ORDER BY name """)
while query.next():
record = query.record()
polygonNameList.append(record.value(0))
query = db.exec_(""" SELECT distinct btype FROM final_poly where btype NOT NULL """)
while query.next():
record = query.record()
polygonTypeList.append(record.value(0))
#print(polygonTypeList)
query = db.exec_(""" SELECT distinct name FROM Final_point ORDER BY name """)
while query.next():
record = query.record()
placemarksNameList.append(record.value(0))
#self.dlg.polygonCombo.clear()
self.dlg.qcombo1.clear()
self.dlg.qcombo2.clear()
self.dlg.q2combo.clear()
self.dlg.q3combo1.clear()
self.dlg.q3combo2.clear()
self.dlg.qcombo1.addItems(polygonNameList)
self.dlg.qcombo2.addItems(polygonTypeList)
self.dlg.q2combo.addItems(polygonNameList)
self.dlg.q3combo1.addItems(placemarksNameList)
self.dlg.q3combo2.addItems(placemarksNameList)
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
pass
def setConnection(self):
uri = QgsDataSourceURI()
uri.setDatabase(self.getCurrentSqlite())
self.uri = uri
def accept(self):
if self.mode == self.ASK_FOR_INPUT_MODE:
# create the input layer (if not already done) and
# update available options
self.reloadInputLayer()
# sanity checks
if self.inLayer is None:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Input layer missing or not valid"))
return
if self.cboTable.currentText() == "":
QMessageBox.information(self, self.tr("Import to database"),
self.tr("Output table name is required"))
return
if self.chkSourceSrid.isEnabled() and self.chkSourceSrid.isChecked():
try:
sourceSrid = self.editSourceSrid.text()
except ValueError:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Invalid source srid: must be an integer"))
return
if self.chkTargetSrid.isEnabled() and self.chkTargetSrid.isChecked():
try:
targetSrid = self.editTargetSrid.text()
except ValueError:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Invalid target srid: must be an integer"))
return
# override cursor
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
# store current input layer crs and encoding, so I can restore it
prevInCrs = self.inLayer.crs()
prevInEncoding = self.inLayer.dataProvider().encoding()
try:
schema = self.outUri.schema() if not self.cboSchema.isEnabled(
) else self.cboSchema.currentText()
table = self.cboTable.currentText()
# get pk and geom field names from the source layer or use the
# ones defined by the user
srcUri = QgsDataSourceURI(self.inLayer.source())
pk = srcUri.keyColumn() if not self.chkPrimaryKey.isChecked(
) else self.editPrimaryKey.text()
if not pk:
pk = self.default_pk
if self.inLayer.hasGeometryType() and self.chkGeomColumn.isEnabled(
):
geom = srcUri.geometryColumn(
) if not self.chkGeomColumn.isChecked(
) else self.editGeomColumn.text()
if not geom:
geom = self.default_geom
else:
geom = None
options = {}
if self.chkLowercaseFieldNames.isEnabled(
) and self.chkLowercaseFieldNames.isChecked():
pk = pk.lower()
if geom:
geom = geom.lower()
options['lowercaseFieldNames'] = True
# get output params, update output URI
self.outUri.setDataSource(schema, table, geom, "", pk)
typeName = self.db.dbplugin().typeName()
providerName = self.db.dbplugin().providerName()
if typeName == 'gpkg':
uri = self.outUri.database()
options['update'] = True
options['driverName'] = 'GPKG'
options['layerName'] = table
else:
uri = self.outUri.uri(False)
if self.chkDropTable.isChecked():
options['overwrite'] = True
if self.chkSinglePart.isEnabled() and self.chkSinglePart.isChecked(
):
options['forceSinglePartGeometryType'] = True
outCrs = None
if self.chkTargetSrid.isEnabled() and self.chkTargetSrid.isChecked(
):
targetSrid = int(self.editTargetSrid.text())
outCrs = QgsCoordinateReferenceSystem(targetSrid)
# update input layer crs and encoding
if self.chkSourceSrid.isEnabled() and self.chkSourceSrid.isChecked(
):
sourceSrid = int(self.editSourceSrid.text())
inCrs = QgsCoordinateReferenceSystem(sourceSrid)
self.inLayer.setCrs(inCrs)
if self.chkEncoding.isEnabled() and self.chkEncoding.isChecked():
enc = self.cboEncoding.currentText()
self.inLayer.setProviderEncoding(enc)
onlySelected = self.chkSelectedFeatures.isChecked()
# do the import!
ret, errMsg = QgsVectorLayerImport.importLayer(
self.inLayer, uri, providerName, outCrs, onlySelected, False,
options)
except Exception as e:
ret = -1
errMsg = unicode(e)
finally:
# restore input layer crs and encoding
self.inLayer.setCrs(prevInCrs)
self.inLayer.setProviderEncoding(prevInEncoding)
# restore cursor
QApplication.restoreOverrideCursor()
if ret != 0:
output = QgsMessageViewer()
output.setTitle(self.tr("Import to database"))
output.setMessageAsPlainText(
self.tr("Error %d\n%s") % (ret, errMsg))
output.showMessage()
return
# create spatial index
if self.chkSpatialIndex.isEnabled() and self.chkSpatialIndex.isChecked(
):
self.db.connector.createSpatialIndex((schema, table), geom)
self.db.connection().reconnect()
self.db.refresh()
QMessageBox.information(self, self.tr("Import to database"),
self.tr("Import was successful."))
return QDialog.accept(self)
def __released(self):
"""
When selection is complete
"""
if self.ownSettings is None:
self.__iface.messageBar().pushMessage(QCoreApplication.translate(
"VDLTools", "No settings given !!"),
level=QgsMessageBar.CRITICAL,
duration=0)
return
if self.ownSettings.controlUriDb is None:
self.__iface.messageBar().pushMessage(QCoreApplication.translate(
"VDLTools", "No control db given !!"),
level=QgsMessageBar.CRITICAL,
duration=0)
return
if self.ownSettings.controlSchemaDb is None:
self.__iface.messageBar().pushMessage(QCoreApplication.translate(
"VDLTools", "No control db schema given !!"),
level=QgsMessageBar.CRITICAL,
duration=0)
return
if self.ownSettings.controlConfigTable is None:
self.__iface.messageBar().pushMessage(QCoreApplication.translate(
"VDLTools", "No control config table given !!"),
level=QgsMessageBar.CRITICAL,
duration=0)
return
self.__configTable = self.ownSettings.controlConfigTable
self.__schemaDb = self.ownSettings.controlSchemaDb
self.connector = DBConnector(self.ownSettings.controlUriDb,
self.__iface)
self.__db = self.connector.setConnection()
"""
Test si la couche / table qui contient l'ensemble des contrôles existe bien dans le projet
"""
if self.__db is not None:
uricfg = QgsDataSourceURI()
uricfg.setConnection(self.__db.hostName(), str(self.__db.port()),
self.__db.databaseName(),
self.__db.userName(), self.__db.password())
uricfg.setDataSource(self.__schemaDb, self.__configTable, None, "",
"id")
self.__layerCfgControl = QgsVectorLayer(uricfg.uri(),
"Liste des contrôles",
"postgres")
# définition d'une couche QMapLayer au niveau QGIS
"""
Test si la zone de contrôle a bien été définie par l'utilisateur
"""
if self.geom is None:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools",
"Request Area not defined, ") +
QCoreApplication.translate(
"VDLTools",
"please define a control area (maintain mouse clic)"),
level=QgsMessageBar.CRITICAL,
duration=5)
else:
if self.geom.area() > self.areaMax:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate(
"VDLTools",
"Please define a smaller control area, max = 1 km2"),
level=QgsMessageBar.CRITICAL,
duration=5)
else:
"""
Liste des contrôles actifs existants
"""
req = QgsFeatureRequest().setFilterExpression(
'"active" is true')
for f in self.__layerCfgControl.getFeatures(req):
lrequests = {}
lrequests["id"] = str(f["id"])
lrequests["name"] = f["layer_name"]
lrequests["code"] = f["code_error"]
lrequests["check"] = f["check_defaut"]
self.__lrequests.append(lrequests)
# trier la liste de dictionnaire
self.__lrequests = sorted(self.__lrequests,
key=lambda k: int(k['id']))
self.__chooseDlg = ChooseControlDialog(self.__lrequests)
self.__chooseDlg.okButton().clicked.connect(self.__onOk)
self.__chooseDlg.cancelButton().clicked.connect(
self.__onCancel)
self.__chooseDlg.show()
def __createCtrlLayers(self, requete):
"""
Création des couches de contrôles
- selon une requête SQL dans la base de données (choix ou des contrôle par l'utilisateur)
- selon une zone géographique définie par l'utilisateur
:param requete: liste des requêtes
"""
self.__iface.messageBar().clearWidgets()
progressMessageBar = self.__iface.messageBar()
# ajout d'une barre de progression pour voir le chargement progressif des couches
progress = QProgressBar()
progress.setMaximum(100)
progressMessageBar.pushWidget(progress)
# récupérer la géométrie définie par l'utilisateur pour l'utiliser dans les requêtes SQL
# conversion en géométrie binaire et dans le bon système de coordonnée)
self.__crs = self.__iface.mapCanvas().mapSettings().destinationCrs(
).postgisSrid()
# défintion du système de coordonnées en sortie (par défaut 21781), récupérer des paramètres du projets
bbox = "(SELECT ST_GeomFromText('" + self.geom.exportToWkt(
) + "'," + str(self.__crs) + "))"
# paramètres de la source des couches à ajouter au projet
uri = QgsDataSourceURI()
uri.setConnection(self.__db.hostName(), str(self.__db.port()),
self.__db.databaseName(), self.__db.userName(),
self.__db.password())
uri.setSrid(str(self.__crs))
outputLayers = [
] # listes des couches de résultats à charger dans le projet
styleLayers = [] # listes des styles de couches (fichier qml)
i = 0
totalError = 0 # décompte des erreurs détectées (nombre d'objets dans chaque couche)
for name in requete:
for q in self.__layerCfgControl.getFeatures(
QgsFeatureRequest(int(name))):
query_fct = q["sql_function"]
query_fct = query_fct.replace("bbox", bbox)
geom_type = QgsWKBTypes.parseType(q["geom_type"])
# récupérer le type de géométrie QGIS "QgsWKBTypes" depuis un type de géométrie WKT Postgis
uri.setWkbType(geom_type)
uri.setDataSource('', query_fct, q["geom_name"], "",
q["key_attribute"])
layer = QgsVectorLayer(uri.uri(), q["layer_name"], "postgres")
totalError = totalError + layer.featureCount()
if layer.featureCount() > 0:
outputLayers.append(layer)
styleLayers.append(str(q["layer_style"]))
percent = (
float(i + 1.0) / float(len(requete))
) * 100 # Faire évoluer la barre de progression du traitement
progress.setValue(percent)
i += 1
if len(outputLayers) > 0:
self.__addCtrlLayers(outputLayers, styleLayers)
self.__iface.messageBar().clearWidgets()
self.__iface.messageBar().pushMessage(
"Info",
QCoreApplication.translate(
"VDLTools",
"All layers have been charged with success in the projet. |"
) + QCoreApplication.translate("VDLTools", "Total errors : ") +
str(totalError),
level=QgsMessageBar.INFO,
duration=10)
else:
self.__iface.messageBar().clearWidgets()
self.__iface.messageBar().pushMessage(
"Info",
QCoreApplication.translate(
"VDLTools",
"Good !! No error detected on the defined area"),
level=QgsMessageBar.INFO,
duration=5)
