def add_postgres_layer(self, name, host, port, database_name, username, schema, table, geom_col, id_col, ssl, qml_file_path, sql_filter): """ Add the database table in the QGis TOC and apply its associated QML. :param name: The name :type name: str :param host: The hostname :type host: str :param port: Aggregated data separated by "|". The first element is the port, the second is the ssl request specification (e.g. require, allow, disable, prefer) :type port: str :param database_name: The database name :type database_name: str :param username: The username for connecting to the database :type username: str :param schema: The database schema :type schema: str :param table: Aggregated data separated by "|". The first is the table name, the second is the sql filter :type table: str :param geom_col: The geometry column name :type geom_col: str :param id_col: The identifier column name :type id_col: str :param ssl: The SSL type request. Expected one of: require, allow, disable or prefer. :type ssl: str :param qml_file_path: The *.qml file path :type qml_file_path: str :param sql_filter: The SQL where condition :type sql_filter: str """ qgs_logger = QgsApplication.messageLog() qgs_logger.logMessage('addWms: name = {}'.format(name), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: host = {}'.format(host), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: port = {}'.format(port), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage( 'addWms: database_name = {}'.format(database_name), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: username = {}'.format(username), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: schema = {}'.format(schema), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: table = {}'.format(table), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: geom_col = {}'.format(geom_col), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: id_col = {}'.format(id_col), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: ssl = {}'.format(ssl), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: self.session_user = {}'.format( str(self.session_user)), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage( 'addWms: qml_file_path = {}'.format(qml_file_path), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: sql_filter = {}'.format(sql_filter), tag=configuration.LOGGER_TAG, level=Qgis.Info) uri = QgsDataSourceUri() ssl_mode = QgsDataSourceUri.SslAllow if ssl == "require": ssl_mode = QgsDataSourceUri.SslRequire if ssl == "allow": ssl_mode = QgsDataSourceUri.SslAllow if ssl == "disable": ssl_mode = QgsDataSourceUri.SslDisable if ssl == "prefer": ssl_mode = QgsDataSourceUri.SslPrefer # Set the connection uri.setConnection(str(host), str(port), str(database_name), str(self.session_user), str(self.session_password), ssl_mode) # In case the geometry column is not defined ignore as parameter, otherwise set it if str(geom_col) == "": uri.setDataSource(str(schema), str(table), None, sql_filter, str(id_col)) else: uri.setDataSource(str(schema), str(table), str(geom_col), sql_filter, str(id_col)) # Instantiate postgres_layer = QgsVectorLayer(uri.uri(), str(name), 'postgres') # In case the layer is valid, add to the QGis TOC if postgres_layer.isValid(): QgsProject.instance().addMapLayer(postgres_layer) postgres_layer.loadNamedStyle(qml_file_path) else: par = "\nhost: " + str(host)\ + "\nport: " + str(port)\ + "\ndbname: " + str(database_name)\ + "\nuser: "******"\nssl: " + str(ssl)\ + "\nschema: " + str(schema)\ + "\ntable: " + str(table) \ + "\ngeom_col: " + str(geom_col) \ + "\nid_col: " + str(id_col) \ + "\npathQMLFile: " + str(qml_file_path) \ + "\nsqlFilter: " + str(sql_filter) self.show_message( "Attenzione!", "Impossibile aggiungere la tabella " + name + " al progetto.\n" + par)
def run(self): """Runs the logic behind the dialogs""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start: self.first_start = False # Start a dialog window self.dlg = PRW_Data_OpvragerDialog() self.dlg.OutputLocation.setStorageMode(1) self.dlg.OutputLocation.setFilePath( self.dlg.OutputLocation.defaultRoot()) # Set a validator on the filename lineEdit so that no random signs can be put in. rx2 = QRegExp(r"^[\w\-. ]+$") filename_validator = QRegExpValidator(rx2) self.dlg.FileName.setValidator(filename_validator) # Show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Extracting values from the dialog form self.selected_layer = self.dlg.cmb_layer.currentLayer() self.dateMax = self.dlg.DateMax.date().toString('yyyy-MM-dd') self.dateMin = self.dlg.DateMin.date().toString('yyyy-MM-dd') self.shpExportBool = self.dlg.exportShapefile.isChecked() self.fileName = self.dlg.FileName.text() self.outputLocation = self.dlg.OutputLocation.filePath() source = self.selected_layer.source() uri = QgsDataSourceUri(source) try: # Check if a database is connected to the layer source assert uri.database( ), '"{layer}" heeft geen connectie met een database.'.format( layer=self.selected_layer.name()) assert self.selected_layer.selectedFeatureCount( ) != 0, 'Geen Objecten zijn geselecteerd in laag: "{layer}".'.format( layer=self.selected_layer.name()) assert self.fileName, 'Er is geen Excel uitvoernaam opgegeven.' assert self.outputLocation, 'Er is geen uitvoermap opgegeven.' except Exception as e: self.iface.messageBar().pushMessage("Error", str(e), level=2, duration=5) raise e return savedUsername = uri.hasParam('username') savedPassword = uri.hasParam('password') host = uri.host() port = uri.port() database = uri.database() self.username = uri.username() self.password = uri.password() self.dsn = cora.makedsn(host=host, port=port, service_name=database) errorMessage = None # If we have a username and password try to connect, otherwise ask for credentials # If the connection fails store the error and show dialog screen for credentials input if savedUsername is True and savedPassword is True: try: self.check_connection() self.run_task() except cora.DatabaseError as e: errorObj, = e.args errorMessage = errorObj.message success = 'false' # Credentials loop while success == 'false': success, errorMessage = \ self.get_credentials( host, port, self.database, message=errorMessage) if success == 'exit': pass elif success == 'true': self.run_task() else: success, errorMessage = \ self.get_credentials( host, port, self.database, username=self.username, password=self.password) # Credentials loop while success == 'false': success, errorMessage = \ self.get_credentials( host, port, self.database, username=self.username, password=self.password, message=errorMessage) if success == 'exit': pass elif success == 'true': self.run_task()
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') 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() for item in self.uniqueModel.findItems("*", Qt.MatchWildcard): if item.data() == keyColumn: self.uniqueCombo.setCurrentIndex( self.uniqueModel.indexFromItem(item).row()) # Finally layer name, filter and selectAtId self.layerNameEdit.setText(layer.name()) self.filter = uri.sql() if uri.selectAtIdDisabled(): self.avoidSelectById.setCheckState(Qt.Checked)
def processAlgorithm(self, parameters, context, feedback): database = self.parameterAsVectorLayer(parameters, self.DATABASE, context) databaseuri = database.dataProvider().dataSourceUri() uri = QgsDataSourceUri(databaseuri) if uri.database() is '': if '|layername' in databaseuri: databaseuri = databaseuri[:databaseuri.find('|layername')] elif '|layerid' in databaseuri: databaseuri = databaseuri[:databaseuri.find('|layerid')] uri = QgsDataSourceUri('dbname=\'%s\'' % (databaseuri)) db = spatialite.GeoDB(uri) overwrite = self.parameterAsBool(parameters, self.OVERWRITE, context) createIndex = self.parameterAsBool(parameters, self.CREATEINDEX, context) convertLowerCase = self.parameterAsBool(parameters, self.LOWERCASE_NAMES, context) dropStringLength = self.parameterAsBool(parameters, self.DROP_STRING_LENGTH, context) forceSinglePart = self.parameterAsBool(parameters, self.FORCE_SINGLEPART, context) primaryKeyField = self.parameterAsString(parameters, self.PRIMARY_KEY, context) or 'id' encoding = self.parameterAsString(parameters, self.ENCODING, context) source = self.parameterAsSource(parameters, self.INPUT, context) if source is None: raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) table = self.parameterAsString(parameters, self.TABLENAME, context) if table: table.strip() if not table or table == '': table = source.sourceName() table = table.replace('.', '_') table = table.replace(' ', '').lower() providerName = 'spatialite' geomColumn = self.parameterAsString(parameters, self.GEOMETRY_COLUMN, context) if not geomColumn: geomColumn = 'geom' options = {} if overwrite: options['overwrite'] = True if convertLowerCase: options['lowercaseFieldNames'] = True geomColumn = geomColumn.lower() if dropStringLength: options['dropStringConstraints'] = True if forceSinglePart: options['forceSinglePartGeometryType'] = True # Clear geometry column for non-geometry tables if source.wkbType() == QgsWkbTypes.NoGeometry: geomColumn = None uri = db.uri uri.setDataSource('', table, geomColumn, '', primaryKeyField) if encoding: options['fileEncoding'] = encoding exporter = QgsVectorLayerExporter(uri.uri(), providerName, source.fields(), source.wkbType(), source.sourceCrs(), overwrite, options) if exporter.errorCode() != QgsVectorLayerExporter.NoError: raise QgsProcessingException( self.tr('Error importing to Spatialite\n{0}').format( exporter.errorMessage())) features = source.getFeatures() total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(features): if feedback.isCanceled(): break if not exporter.addFeature(f, QgsFeatureSink.FastInsert): feedback.reportError(exporter.errorMessage()) feedback.setProgress(int(current * total)) exporter.flushBuffer() if exporter.errorCode() != QgsVectorLayerExporter.NoError: raise QgsProcessingException( self.tr('Error importing to Spatialite\n{0}').format( exporter.errorMessage())) if geomColumn and createIndex: db.create_spatial_index(table, geomColumn) return {}
def charge_vector_layers_periodo(self, cont_per): self.cont_per = str(cont_per) # Clean Qgis Map Later Registry # QgsMapLayerRegistry.instance().removeAllMapLayers() # Get the user input, starting with the table name # self.find_us_cutted(data) cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'config.cfg') file_path = '{}{}'.format(self.HOME, cfg_rel_path) conf = open(file_path, "r") con_sett = conf.read() conf.close() settings = Settings(con_sett) settings.set_configuration() if settings.SERVER == 'sqlite': sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite') db_file_path = '{}{}'.format(self.HOME, sqliteDB_path) uri = QgsDataSourceUri() uri.setDatabase(db_file_path) cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'" uri.setDataSource('', 'pyarchinit_us_view', 'the_geom', cont_per_string, "ROWID") layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite') srs = QgsCoordinateReferenceSystem( self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId) if layerUS.isValid(): QMessageBox.warning(self, "TESTER", "OK Layer US valido", QMessageBox.Ok) # self.USLayerId = layerUS.getLayerID() # style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_view.qml') style_path = QFileDialog.getOpenFileName( self, 'Open file', self.LAYER_STYLE_PATH) layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], True) else: QMessageBox.warning(self, "TESTER", "OK Layer US non valido", QMessageBox.Ok) uri.setDataSource('', 'pyarchinit_quote_view', 'the_geom', cont_per_string, "ROWID") layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite') if layerQUOTE.isValid(): # self.USLayerId = layerUS.getLayerID() style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'quote_us_view.qml') layerQUOTE.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerQUOTE], True) elif settings.SERVER == 'postgres': uri = QgsDataSourceUri() # set host name, port, database name, username and password uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD) # cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'" srs = QgsCoordinateReferenceSystem( self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId) uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", cont_per_string, "id") layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres") if layerUS.isValid(): layerUS.setCrs(srs) # self.USLayerId = layerUS.getLayerID() # style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml') style_path = QFileDialog.getOpenFileName( self, 'Open file', self.LAYER_STYLE_PATH) layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], True) uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", cont_per_string, "gid") layerQUOTE = QgsVectorLayer(uri.uri(), "Quote Unita' Stratigrafiche", "postgres") if layerQUOTE.isValid(): layerQUOTE.setCrs(srs) style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml') layerQUOTE.loadNamedStyle(style_path) try: QgsProject.instance().addMapLayers([layerQUOTE], True) except Exception as e: pass
def charge_individui_us(self, data): # Clean Qgis Map Later Registry # QgsMapLayerRegistry.instance().removeAllMapLayers() # Get the user input, starting with the table name # self.find_us_cutted(data) cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'config.cfg') file_path = '{}{}'.format(self.HOME, cfg_rel_path) conf = open(file_path, "r") con_sett = conf.read() conf.close() settings = Settings(con_sett) settings.set_configuration() if settings.SERVER == 'sqlite': sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite') db_file_path = '{}{}'.format(self.HOME, sqliteDB_path) gidstr = id_us = "id_us = '" + str(data[0]) + "'" if len(data) > 1: for i in range(len(data)): gidstr += " OR id_us = '" + str(data[i]) + "'" uri = QgsDataSourceUri() uri.setDatabase(db_file_path) uri.setDataSource('', 'pyarchinit_us_view', 'Geometry', gidstr, "gid") layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite') ###################################################################� if layerUS.isValid(): # self.USLayerId = layerUS.getLayerID() # style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_caratterizzazioni.qml') # layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], True) uri.setDataSource('', 'pyarchinit_quote_view', 'Geometry', gidstr, "gid") layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite') if layerQUOTE.isValid(): QgsProject.instance().addMapLayers([layerQUOTE], True) elif settings.SERVER == 'postgres': uri = QgsDataSourceUri() # set host name, port, database name, username and password uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD) gidstr = id_us = "id_archzoo = " + str(data[0]) if len(data) > 1: for i in range(len(data)): gidstr += " OR id_archzoo = " + str(data[i]) srs = QgsCoordinateReferenceSystem( self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId) uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", gidstr, "gid") layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres") if layerUS.isValid(): layerUS.setCrs(srs) # self.USLayerId = layerUS.getLayerID() # style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml') style_path = QFileDialog.getOpenFileName( self, 'Open file', self.LAYER_STYLE_PATH) layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], True) uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", gidstr, "gid") layerQUOTE = QgsVectorLayer(uri.uri(), "Quote Unita' Stratigrafiche", "postgres") if layerQUOTE.isValid(): layerQUOTE.setCrs(srs) style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml') layerQUOTE.loadNamedStyle(style_path) try: QgsProject.instance().addMapLayers([layerQUOTE], True) except Exception as e: pass
def newEntranceLayer(self): vl = QgsVectorLayer("Point?crs=", "memory:Entrances", "memory") provider = vl.dataProvider() provider.addAttributes([ QgsField(EntranceTool.id_attribute, QVariant.Int), QgsField(EntranceTool.category_attribute, QVariant.String), QgsField(EntranceTool.subcat_attribute, QVariant.String), QgsField(EntranceTool.level_attribute, QVariant.Double) ]) if vl.crs().toWkt() == "": vl.setCrs(QgsProject.instance().crs()) vl.updateFields() if self.entrancedlg.e_shp_radioButton.isChecked( ): # layer_type == 'shapefile': path = self.entrancedlg.lineEditEntrances.text() if path and path != '': filename = os.path.basename(path) location = os.path.abspath(path) crs = QgsCoordinateReferenceSystem() crs.createFromSrid(3857) shph.createShapeFile(vl, path, crs) vl = self.iface.addVectorLayer(location, filename[:-4], "ogr") else: vl = 'invalid data source' elif self.entrancedlg.e_postgis_radioButton.isChecked(): db_path = self.entrancedlg.lineEditEntrances.text() if db_path and db_path != '': (database, schema, table_name) = db_path.split(':') db_con_info = self.entrancedlg.dbsettings_dlg.available_dbs[ database] uri = QgsDataSourceUri() # passwords, usernames need to be empty if not provided or else connection will fail if 'service' in list(db_con_info.keys()): uri.setConnection(db_con_info['service'], '', '', '') elif 'password' in list(db_con_info.keys()): uri.setConnection(db_con_info['host'], db_con_info['port'], db_con_info['dbname'], db_con_info['user'], db_con_info['password']) else: print(db_con_info) # db_con_info['host'] uri.setConnection('', db_con_info['port'], db_con_info['dbname'], '', '') uri.setDataSource(schema, table_name, "geom") error = QgsVectorLayerExporter.exportLayer( vl, uri.uri(), "postgres", vl.crs()) if error[0] != QgsVectorLayerExporter.NoError: print("Error when creating postgis layer: ", error[1]) vl = 'duplicate' else: vl = QgsVectorLayer(uri.uri(), table_name, "postgres") else: vl = 'invalid data source' if vl == 'invalid data source': msgBar = self.iface.messageBar() msg = msgBar.createMessage(u'Specify output path!') msgBar.pushWidget(msg, Qgis.Info, 10) elif vl == 'duplicate': msgBar = self.iface.messageBar() msg = msgBar.createMessage(u'Fronatges layer already exists!') msgBar.pushWidget(msg, Qgis.Info, 10) elif not vl: msgBar = self.iface.messageBar() msg = msgBar.createMessage(u'Entrance layer failed to load!') msgBar.pushWidget(msg, Qgis.Info, 10) else: QgsProject.instance().addMapLayer(vl) msgBar = self.iface.messageBar() msg = msgBar.createMessage(u'Entrances layer created!') msgBar.pushWidget(msg, Qgis.Info, 10) vl.startEditing() self.updateEntranceLayer() self.entrancedlg.closePopUpEntrances()
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) uri = self.outUri.uri(False) providerName = self.db.dbplugin().providerName() if self.chkDropTable.isChecked(): options['overwrite'] = True if self.chkSinglePart.isEnabled() and self.chkSinglePart.isChecked(): options['forceSinglePartGeometryType'] = True outCrs = QgsCoordinateReferenceSystem() 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 = str(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 {0}\n{1}").format(ret, errMsg)) output.showMessage() return # create spatial index if self.chkSpatialIndex.isEnabled() and self.chkSpatialIndex.isChecked(): self.db.connector.createSpatialIndex((schema, table), geom) QMessageBox.information(self, self.tr("Import to database"), self.tr("Import was successful.")) return QDialog.accept(self)
def testExtentFromGeometryTable(self): """ Check if the behavior of the mssql provider if extent is defined in the geometry_column table """ # Create a layer layer = QgsVectorLayer( "Point?field=id:integer&field=fldtxt:string&field=fldint:integer", "layer", "memory") pr = layer.dataProvider() f1 = QgsFeature() f1.setAttributes([1, "test", 1]) f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(1, 2))) f2 = QgsFeature() f2.setAttributes([2, "test2", 3]) f3 = QgsFeature() f3.setAttributes([3, "test2", NULL]) f3.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(3, 2))) f4 = QgsFeature() f4.setAttributes([4, NULL, 3]) f4.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(4, 3))) pr.addFeatures([f1, f2, f3, f4]) uri = '{} table="qgis_test"."layer_extent_in_geometry_table" sql='.format( self.dbconn) QgsVectorLayerExporter.exportLayer( layer, uri, 'mssql', QgsCoordinateReferenceSystem('EPSG:4326')) layerUri = QgsDataSourceUri(uri) # Load and check if the layer is valid loadedLayer = QgsVectorLayer(layerUri.uri(), "valid", "mssql") self.assertTrue(loadedLayer.isValid()) extent = loadedLayer.extent() self.assertEqual(extent.toString(1), QgsRectangle(1.0, 2.0, 4.0, 3.0).toString(1)) # Load with flag extent in geometry_columns table and check if the layer is still valid and extent doesn't change layerUri.setParam('extentInGeometryColumns', '1') loadedLayer = QgsVectorLayer(layerUri.uri(), "invalid", "mssql") self.assertTrue(loadedLayer.isValid()) extent = loadedLayer.extent() self.assertEqual(extent.toString(1), QgsRectangle(1.0, 2.0, 4.0, 3.0).toString(1)) md = QgsProviderRegistry.instance().providerMetadata('mssql') conn = md.createConnection(self.dbconn, {}) conn.addField(QgsField('qgis_xmin', QVariant.Double, 'FLOAT(24)'), 'dbo', 'geometry_columns') conn.addField(QgsField('qgis_xmax', QVariant.Double, 'FLOAT(24)'), 'dbo', 'geometry_columns') conn.addField(QgsField('qgis_ymin', QVariant.Double, 'FLOAT(24)'), 'dbo', 'geometry_columns') conn.addField(QgsField('qgis_ymax', QVariant.Double, 'FLOAT(24)'), 'dbo', 'geometry_columns') # try with empty attribute layerUri.setParam('extentInGeometryColumns', '1') loadedLayer = QgsVectorLayer(layerUri.uri(), "invalid", "mssql") self.assertTrue(loadedLayer.isValid()) self.assertTrue(loadedLayer.isValid()) extent = loadedLayer.extent() self.assertEqual(extent.toString(1), QgsRectangle(1.0, 2.0, 4.0, 3.0).toString(1)) conn.execSql( 'UPDATE dbo.geometry_columns SET qgis_xmin=0, qgis_xmax=5.5, qgis_ymin=0.5, qgis_ymax=6 WHERE f_table_name=\'layer_extent_in_geometry_table\'' ) # try with valid attribute layerUri.setParam('extentInGeometryColumns', '1') loadedLayer = QgsVectorLayer(layerUri.uri(), "valid", "mssql") self.assertTrue(loadedLayer.isValid()) extent = loadedLayer.extent() self.assertEqual(extent.toString(1), QgsRectangle(0.0, 0.5, 5.5, 6.0).toString(1))
def load_work_layers(self): def check_conn(host, port, database, user, password): try: conn = psycopg2.connect(host=host,port=port, database=database, user=user, password=password, connect_timeout=1) conn.close() #self.iface.messageBar().pushMessage(self.tr('Povezava uspešna')) return True except: #self.iface.messageBar().pushMessage(self.tr('Povezava neuspešna, napačen uporabnik ali geslo!')) return False host = parameters(self)[0] database = parameters(self)[1] port = parameters(self)[4] table = get_work_layers(self) uri = QgsDataSourceUri() root = QgsProject.instance().layerTreeRoot() self.host = parameters(self)[0] self.database = parameters(self)[1] self.port = parameters(self)[4] #Input authentication authcfg = self.dlg.mAuthConfigSelect.configId() auth_mgr = QgsApplication.authManager() auth_cfg = QgsAuthMethodConfig() auth_mgr.loadAuthenticationConfig(authcfg, auth_cfg, True) auth = auth_cfg.configMap() # Input Username, password user = self.dlg.user_input.text() password = self.dlg.pass_input.text() def auth_text(user, password): authMgr = QgsApplication.authManager() cfg = QgsAuthMethodConfig() cfg.setName(user) cfg.setMethod('Basic') cfg.setConfig('username', user) cfg.setConfig('password', password) authMgr.storeAuthenticationConfig(cfg) return(cfg) aut_meth = 0 if user: check_conn(host, port, database, user, password) authentication = auth_text(user, password) aut_meth = 1 elif auth_mgr: try: check_conn(host, port, database, auth["username"], auth["password"]) authentication = auth_cfg except: pass else: self.iface.messageBar().pushMessage(self.tr("Napačen uporabnik ali geslo."), self.tr("Potrdi za javni dostop."), level=Qgis.Critical) text = self.tr('Uporabljam javni dostop:') uri.setConnection(host, port, database, None, None) (success, user, passwd) = QgsCredentials.instance().get(text, parameters(self)[3], parameters(self)[2]) if success: if check_conn(host, port, database, user, passwd): user = user password = passwd else: check_conn(host, port, database, user, passwd) self.iface.messageBar().pushMessage(self.tr('Povezava neuspešna, napačen uporabnik ali geslo!')) #List of groups and layers w_layers = [r[1] for r in table.getFeatures()] groups = [self.tr('Delovni sloji')] def load_wl(shema, table, geom, sql, fid): if geom == '': geom = None uri.setConnection(self.host, self.port, self.database, "", "", QgsDataSourceUri.SslDisable,"") uri.setAuthConfigId(authentication.id()) uri.setDataSource(shema, table, geom, sql, fid) layer=QgsVectorLayer (uri .uri(False), table, "postgres") return layer #Attribute form config for layer ZLS Int def field_to_value_relation(layer): fields = layer.fields() pattern = re.compile(r'Vrsta') fields_vrsta = [field for field in fields if pattern.match(field.name())] if len(fields_vrsta) > 0: config = {'AllowMulti': False, 'AllowNull': False, 'FilterExpression': 'Sloj = current_value(\'Sloj\') and \"Opombe\" =\'kategorije\'', 'Key': 'Vrsta', 'Layer': layer.id(), 'NofColumns': 1, 'OrderByValue': False, 'UseCompleter': False, 'Value': 'Vrsta'} for field in fields_vrsta: field_idx = fields.indexOf(field.name()) if field_idx >= 0: try: widget_setup = QgsEditorWidgetSetup('ValueRelation',config) layer.setEditorWidgetSetup(field_idx, widget_setup) except: pass else: return False else: return False return True #Join fields function def field_join(t_layer, s_layer, t_field, s_field): joinObject = QgsVectorLayerJoinInfo() joinObject.setJoinFieldName(s_field) joinObject.setTargetFieldName(t_field) joinObject.setJoinLayerId(s_layer.id()) joinObject.setUsingMemoryCache(True) joinObject.setJoinLayer(s_layer) t_layer.addJoin(joinObject) #Populate list of accessible layers layers_list = [] for f in table.getFeatures(): if f[3] != 'admin': print(f[2]) try: layer = load_wl(f[2], f[1], f[4], "", f[5]) if layer.isValid(): layers_list.append(layer) except: continue if not root.findGroup(self.tr('Delovni sloji')) and len(layers_list) != 0: w_group = root.addGroup(self.tr('Delovni sloji')) else: w_group = root.findGroup(self.tr('Delovni sloji')) # load layers for current, layer in enumerate(layers_list): QgsProject.instance().addMapLayer(layer, False) w_group.insertChildNode(current, QgsLayerTreeLayer(layer)) myLayerNode = root.findLayer(layer.id()) myLayerNode.setExpanded(False) if layer.name() == 'ZLS Interpretacija_delovno': field_to_value_relation(layer) if aut_meth == 1: authMgr = QgsApplication.authManager() authMgr.removeAuthenticationConfig(authentication.id())
def uri(self): return QgsDataSourceUri("qgis")
def testDataSourceUri(self): ds = QgsDataSourceUri() ds.setConnection(aHost='my_host', aPort='2322', aDatabase='my_db', aUsername='******', aPassword='******') self.assertEqual(ds.__repr__(), "<QgsDataSourceUri: dbname='my_db' host=my_host port=2322 user='******' password='******'>")
def processAlgorithm(self, parameters, context, feedback): connection_name = self.parameterAsConnectionName( parameters, self.DATABASE, context) # resolve connection details to uri try: md = QgsProviderRegistry.instance().providerMetadata('postgres') conn = md.createConnection(connection_name) except QgsProviderConnectionException: raise QgsProcessingException( self.tr('Could not retrieve connection details for {}').format( connection_name)) schema = self.parameterAsSchema(parameters, self.SCHEMA, context) overwrite = self.parameterAsBoolean(parameters, self.OVERWRITE, context) createIndex = self.parameterAsBoolean(parameters, self.CREATEINDEX, context) convertLowerCase = self.parameterAsBoolean(parameters, self.LOWERCASE_NAMES, context) dropStringLength = self.parameterAsBoolean(parameters, self.DROP_STRING_LENGTH, context) forceSinglePart = self.parameterAsBoolean(parameters, self.FORCE_SINGLEPART, context) primaryKeyField = self.parameterAsString(parameters, self.PRIMARY_KEY, context) or 'id' encoding = self.parameterAsString(parameters, self.ENCODING, context) source = self.parameterAsSource(parameters, self.INPUT, context) if source is None: raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) table = self.parameterAsDatabaseTableName(parameters, self.TABLENAME, context) if table: table.strip() if not table or table == '': table = source.sourceName() table = table.replace('.', '_') table = table.replace(' ', '')[0:62] providerName = 'postgres' geomColumn = self.parameterAsString(parameters, self.GEOMETRY_COLUMN, context) if not geomColumn: geomColumn = 'geom' options = {} if overwrite: options['overwrite'] = True if convertLowerCase: options['lowercaseFieldNames'] = True geomColumn = geomColumn.lower() if dropStringLength: options['dropStringConstraints'] = True if forceSinglePart: options['forceSinglePartGeometryType'] = True # Clear geometry column for non-geometry tables if source.wkbType() == QgsWkbTypes.NoGeometry: geomColumn = None uri = QgsDataSourceUri(conn.uri()) uri.setSchema(schema) uri.setTable(table) uri.setKeyColumn(primaryKeyField) uri.setGeometryColumn(geomColumn) if encoding: options['fileEncoding'] = encoding exporter = QgsVectorLayerExporter(uri.uri(), providerName, source.fields(), source.wkbType(), source.sourceCrs(), overwrite, options) if exporter.errorCode() != QgsVectorLayerExporter.NoError: raise QgsProcessingException( self.tr('Error importing to PostGIS\n{0}').format( exporter.errorMessage())) features = source.getFeatures() total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(features): if feedback.isCanceled(): break if not exporter.addFeature(f, QgsFeatureSink.FastInsert): feedback.reportError(exporter.errorMessage()) feedback.setProgress(int(current * total)) exporter.flushBuffer() if exporter.errorCode() != QgsVectorLayerExporter.NoError: raise QgsProcessingException( self.tr('Error importing to PostGIS\n{0}').format( exporter.errorMessage())) if geomColumn and createIndex: try: options = QgsAbstractDatabaseProviderConnection.SpatialIndexOptions( ) options.geometryColumnName = geomColumn conn.createSpatialIndex(schema, table, options) except QgsProviderConnectionException as e: raise QgsProcessingException( self.tr('Error creating spatial index:\n{0}').format(e)) try: conn.vacuum(schema, table) except QgsProviderConnectionException as e: feedback.reportError( self.tr('Error vacuuming table:\n{0}').format(e)) return {}
def createVectorWriter(destination, encoding, fields, geometryType, crs, context, options=None): layer = None sink = None if encoding is None: settings = QgsSettings() encoding = settings.value('/Processing/encoding', 'System', str) if destination.startswith(MEMORY_LAYER_PREFIX): uri = QgsWkbTypes.displayString(geometryType) + "?uuid=" + str( uuid.uuid4()) if crs.isValid(): uri += '&crs=' + crs.authid() fieldsdesc = [] for f in fields: qgsfield = _toQgsField(f) fieldsdesc.append( 'field=%s:%s' % (qgsfield.name(), TYPE_MAP_MEMORY_LAYER.get(qgsfield.type(), "string"))) if fieldsdesc: uri += '&' + '&'.join(fieldsdesc) layer = QgsVectorLayer(uri, destination, 'memory') sink = layer.dataProvider() context.temporaryLayerStore().addMapLayer(layer, False) elif destination.startswith(POSTGIS_LAYER_PREFIX): uri = QgsDataSourceUri(destination[len(POSTGIS_LAYER_PREFIX):]) connInfo = uri.connectionInfo() (success, user, passwd) = QgsCredentials.instance().get(connInfo, None, None) if success: QgsCredentials.instance().put(connInfo, user, passwd) else: raise GeoAlgorithmExecutionException( "Couldn't connect to database") try: db = postgis.GeoDB(host=uri.host(), port=int(uri.port()), dbname=uri.database(), user=user, passwd=passwd) except postgis.DbError as e: raise GeoAlgorithmExecutionException( "Couldn't connect to database:\n%s" % e.message) def _runSQL(sql): try: db._exec_sql_and_commit(str(sql)) except postgis.DbError as e: raise GeoAlgorithmExecutionException( 'Error creating output PostGIS table:\n%s' % e.message) fields = [_toQgsField(f) for f in fields] fieldsdesc = ",".join( '%s %s' % (f.name(), TYPE_MAP_POSTGIS_LAYER.get(f.type(), "VARCHAR")) for f in fields) _runSQL("CREATE TABLE %s.%s (%s)" % (uri.schema(), uri.table().lower(), fieldsdesc)) if geometryType != QgsWkbTypes.NullGeometry: _runSQL( "SELECT AddGeometryColumn('{schema}', '{table}', 'the_geom', {srid}, '{typmod}', 2)" .format( table=uri.table().lower(), schema=uri.schema(), srid=crs.authid().split(":")[-1], typmod=QgsWkbTypes.displayString(geometryType).upper())) layer = QgsVectorLayer(uri.uri(), uri.table(), "postgres") sink = layer.dataProvider() context.temporaryLayerStore().addMapLayer(layer, False) elif destination.startswith(SPATIALITE_LAYER_PREFIX): uri = QgsDataSourceUri(destination[len(SPATIALITE_LAYER_PREFIX):]) try: db = spatialite.GeoDB(uri=uri) except spatialite.DbError as e: raise GeoAlgorithmExecutionException( "Couldn't connect to database:\n%s" % e.message) def _runSQL(sql): try: db._exec_sql_and_commit(str(sql)) except spatialite.DbError as e: raise GeoAlgorithmExecutionException( 'Error creating output Spatialite table:\n%s' % str(e)) fields = [_toQgsField(f) for f in fields] fieldsdesc = ",".join( '%s %s' % (f.name(), TYPE_MAP_SPATIALITE_LAYER.get(f.type(), "VARCHAR")) for f in fields) _runSQL("DROP TABLE IF EXISTS %s" % uri.table().lower()) _runSQL("CREATE TABLE %s (%s)" % (uri.table().lower(), fieldsdesc)) if geometryType != QgsWkbTypes.NullGeometry: _runSQL( "SELECT AddGeometryColumn('{table}', 'the_geom', {srid}, '{typmod}', 2)" .format( table=uri.table().lower(), srid=crs.authid().split(":")[-1], typmod=QgsWkbTypes.displayString(geometryType).upper())) layer = QgsVectorLayer(uri.uri(), uri.table(), "spatialite") sink = layer.dataProvider() context.temporaryLayerStore().addMapLayer(layer, False) else: formats = QgsVectorFileWriter.supportedFiltersAndFormats() OGRCodes = {} for (key, value) in list(formats.items()): extension = str(key) extension = extension[extension.find('*.') + 2:] extension = extension[:extension.find(' ')] OGRCodes[extension] = value OGRCodes['dbf'] = "DBF file" extension = destination[destination.rfind('.') + 1:] if extension not in OGRCodes: extension = 'shp' destination = destination + '.shp' if geometryType == QgsWkbTypes.NoGeometry: if extension == 'shp': extension = 'dbf' destination = destination[:destination.rfind('.')] + '.dbf' if extension not in NOGEOMETRY_EXTENSIONS: raise GeoAlgorithmExecutionException( "Unsupported format for tables with no geometry") qgsfields = QgsFields() for field in fields: qgsfields.append(_toQgsField(field)) # use default dataset/layer options dataset_options = QgsVectorFileWriter.defaultDatasetOptions( OGRCodes[extension]) layer_options = QgsVectorFileWriter.defaultLayerOptions( OGRCodes[extension]) sink = QgsVectorFileWriter(destination, encoding, qgsfields, geometryType, crs, OGRCodes[extension], dataset_options, layer_options) return sink, destination, layer
def add_layers(self): obs_db_existing = self.root.findGroup('Midvatten_OBS_DB') if obs_db_existing: position_index = 1 else: position_index = 0 MyGroup = qgis.core.QgsLayerTreeGroup(name=self.group_name, checked=True) self.root.insertChildNode(position_index, MyGroup) MySubGroup = MyGroup.addGroup('värdeförråd') uri = QgsDataSourceUri() uri.setDatabase(self.dbpath) canvas = self.iface.mapCanvas() layer_list = [] layer_name_list = [] layer_dict = dict() # name as key and layer as value # first add all data domains (beginning with zz_ in the database) conn_ok, dd_tables = utils.sql_load_fr_db( "select name from sqlite_master where name like 'zz_%'", self.dbpath) if not conn_ok: return d_domain_tables = [str(dd_table[0]) for dd_table in dd_tables] for tablename in d_domain_tables: uristring = 'dbname="' + self.dbpath + '" table="' + tablename + '"' layer = QgsVectorLayer(uristring, tablename, 'spatialite') layer_list.append(layer) layer_name_list.append(layer.name()) # Then some specific tables for tablename in ['tillromr_summaflode' ]: #, 'profil' # Implementera vid behov try: uristring = 'dbname="' + self.dbpath + '" ' + r"""table='{}'""".format( tablename) layer = QgsVectorLayer(uristring, tablename, 'spatialite') layer_list.append(layer) except: pass #then load all spatial layers layers = default_layers( ) # ordered dict with layer-name:(zz_layer-name,layer_name_for_map_legend) for tablename, tup in list(layers.items()): try: uri.setDataSource('', tablename, 'geometry') layer = QgsVectorLayer( uri.uri(), tablename, 'spatialite' ) # Adding the layer as 'spatialite' instead of ogr vector layer is preferred if layer.isValid(): layer_list.append(layer) layer_name_list.append(layer.name()) else: qgis.utils.iface.messageBar().pushMessage( "Warning", "Table %s was not valid. DB probably created w old plugin version." % str(tablename), 1, duration=5) except: qgis.utils.iface.messageBar().pushMessage( "Warning", "Table %s not found in db. DB probably created w old plugin version." % str(tablename), 1, duration=5) #now loop over all the layers and set styles etc for layer in layer_list: QgsProject.instance().addMapLayers([layer], False) if layer.name() in d_domain_tables: MySubGroup.insertLayer(0, layer) else: MyGroup.insertLayer(0, layer) layer_dict[layer.name()] = layer #now try to load the style file stylefile = os.path.join(os.sep, os.path.dirname(__file__), "sql_strings", layer.name() + ".qml") try: layer.loadNamedStyle(stylefile) except: pass if layer.name() == 'gvmag': #zoom to gvmag extent canvas.setExtent(layer.extent()) else: pass if layer.name() in defs.unchecked_layers(): #QgsProject.instance().layerTreeRoot().findLayer(layer.id()).setItemVisibilityChecked(False) MyGroup.findLayer(layer.id()).setItemVisibilityChecked(False) #w_lvls_last_geom.setItemVisibilityCheckedRecursive(False) MySubGroup.setExpanded(False) # fix value relations for lyr in list(layers.keys()): if lyr in layer_name_list: if not layers[lyr][0] == None: #self.create_layer_value_relations(layer_dict[lyr], layer_dict[layers[lyr]], layer_dict[lyr].dataProvider().fieldNameIndex('typ'), 'typ','beskrivning') self.create_layer_value_relations( layer_dict[lyr], layer_dict[layers[lyr][0]], layer_dict[lyr].dataProvider().fieldNameIndex('typ'), 'typ', 'beskrivning') #special fix for gvflode self.create_layer_value_relations( layer_dict['gvflode'], layer_dict['zz_gvmag'], layer_dict['gvflode'].dataProvider().fieldNameIndex('intermag'), 'typ', 'beskrivning') for projektdependent_layer in ['profillinje' ]: #, 'profil' # Implementera vid behov if projektdependent_layer in layer_dict: self.create_layer_value_relations( layer_dict[projektdependent_layer], layer_dict['zz_projekt'], layer_dict[projektdependent_layer].dataProvider( ).fieldNameIndex('projekt'), 'pkuid', 'namn') #last, rename to readable names in map legend for layer in layer_list: #for lyr in layers.keys(): if layer.name() in layers: try: layer.setLayerName(layers[layer.name()][1]) except: pass #finally refresh canvas canvas.refresh()
def __init__(self, uri): DBConnector.__init__(self, uri) self.host = uri.host() or os.environ.get('PGHOST') self.port = uri.port() or os.environ.get('PGPORT') username = uri.username() or os.environ.get('PGUSER') password = uri.password() or os.environ.get('PGPASSWORD') # Do not get db and user names from the env if service is used if not uri.service(): if username is None: username = os.environ.get('USER') self.dbname = uri.database() or os.environ.get( 'PGDATABASE') or username uri.setDatabase(self.dbname) expandedConnInfo = self._connectionInfo() try: self.connection = psycopg2.connect(expandedConnInfo) except self.connection_error_types() as e: err = str(e) uri = self.uri() conninfo = uri.connectionInfo(False) for i in range(3): (ok, username, password) = QgsCredentials.instance().get( conninfo, username, password, err) if not ok: raise ConnectionError(e) if username: uri.setUsername(username) if password: uri.setPassword(password) newExpandedConnInfo = uri.connectionInfo(True) try: self.connection = psycopg2.connect(newExpandedConnInfo) QgsCredentials.instance().put(conninfo, username, password) except self.connection_error_types() as e: if i == 2: raise ConnectionError(e) err = str(e) finally: # remove certs (if any) of the expanded connectionInfo expandedUri = QgsDataSourceUri(newExpandedConnInfo) sslCertFile = expandedUri.param("sslcert") if sslCertFile: sslCertFile = sslCertFile.replace("'", "") os.remove(sslCertFile) sslKeyFile = expandedUri.param("sslkey") if sslKeyFile: sslKeyFile = sslKeyFile.replace("'", "") os.remove(sslKeyFile) sslCAFile = expandedUri.param("sslrootcert") if sslCAFile: sslCAFile = sslCAFile.replace("'", "") os.remove(sslCAFile) finally: # remove certs (if any) of the expanded connectionInfo expandedUri = QgsDataSourceUri(expandedConnInfo) sslCertFile = expandedUri.param("sslcert") if sslCertFile: sslCertFile = sslCertFile.replace("'", "") os.remove(sslCertFile) sslKeyFile = expandedUri.param("sslkey") if sslKeyFile: sslKeyFile = sslKeyFile.replace("'", "") os.remove(sslKeyFile) sslCAFile = expandedUri.param("sslrootcert") if sslCAFile: sslCAFile = sslCAFile.replace("'", "") os.remove(sslCAFile) self.connection.set_isolation_level( psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) c = self._execute(None, u"SELECT current_user,current_database()") self.user, self.dbname = self._fetchone(c) self._close_cursor(c) self._checkSpatial() self._checkRaster() self._checkGeometryColumnsTable() self._checkRasterColumnsTable()
def uri(self): return QgsDataSourceUri(self._uri.uri(False))
def ogrConnectionStringAndFormatFromLayer(layer): provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get( conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError( 'Could not connect to PostgreSQL database - check connection info' ) if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == 'mssql': #'dbname=\'db_name\' host=myHost estimatedmetadata=true # srid=27700 type=MultiPolygon table="dbo"."my_table" # #(Shape) sql=' dsUri = layer.dataProvider().uri() ogrstr = 'MSSQL:' ogrstr += 'database={0};'.format(dsUri.database()) ogrstr += 'server={0};'.format(dsUri.host()) if dsUri.username() != "": ogrstr += 'uid={0};'.format(dsUri.username()) else: ogrstr += 'trusted_connection=yes;' if dsUri.password() != '': ogrstr += 'pwd={0};'.format(dsUri.password()) ogrstr += 'tables={0}'.format(dsUri.table()) format = 'MSSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError( 'Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return ogrstr, '"' + format + '"'
def publicUri(self): publicUri = QgsDataSourceUri.removePassword(self._uri.uri(False)) return QgsDataSourceUri(publicUri)
def loadMapPreview(self, gidstr): """ if has geometry column load to map canvas """ layerToSet = [] srs = QgsCoordinateReferenceSystem( self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId) sqlite_DB_path = '{}{}{}'.format(self.HOME, os.sep, "pyarchinit_DB_folder") path_cfg = '{}{}{}'.format(sqlite_DB_path, os.sep, 'config.cfg') conf = open(path_cfg, "r") con_sett = conf.read() conf.close() settings = Settings(con_sett) settings.set_configuration() if settings.SERVER == 'postgres': uri = QgsDataSourceUri() # set host name, port, database name, username and password uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD) # layerUS uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", gidstr, "id_archzoo") layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres") if layerUS.isValid(): # self.USLayerId = layerUS.getLayerID() # style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml') # layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], False) layerToSet.append(layerUS) # layerQuote uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", gidstr, "id_us") layerQUOTE = QgsVectorLayer(uri.uri(), "Quote", "postgres") if layerQUOTE.isValid(): # style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml') # layerQUOTE.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerQUOTE], False) layerToSet.append(layerQUOTE) return layerToSet elif settings.SERVER == 'sqlite': sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite') db_file_path = '{}{}'.format(self.HOME, sqliteDB_path) uri = QgsDataSourceUri() uri.setDatabase(db_file_path) # layerQuote uri.setDataSource('', 'pyarchinit_quote_view', 'the_geom', gidstr, "ROWID") layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite') if layerQUOTE.isValid(): ###QMessageBox.warning(self, "TESTER", "OK Layer Quote valido",#QMessageBox.Ok) style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'quote_us_view.qml') layerQUOTE.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerQUOTE], False) layerToSet.append(layerQUOTE) else: pass # QMessageBox.warning(self, "TESTER", "OK Layer Quote non valido", #QMessageBox.Ok) uri.setDataSource('', 'pyarchinit_us_view', 'the_geom', gidstr, "ROWID") layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite') if layerUS.isValid(): # QMessageBox.warning(self, "TESTER", "OK ayer US valido", #QMessageBox.Ok) style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_view.qml') layerUS.loadNamedStyle(style_path) QgsProject.instance().addMapLayers([layerUS], False) layerToSet.append(layerQUOTE) else: pass # QMessageBox.warning(self, "TESTER", "NOT! Layer US not valid",#QMessageBox.Ok) return layerToSet
def connect(self, parent=None): conn_name = self.connectionName() settings = QgsSettings() settings.beginGroup(u"/{0}/{1}".format(self.connectionSettingsKey(), conn_name)) if not settings.contains("database"): # non-existent entry? raise InvalidDataException( self.tr( 'There is no defined database connection "{0}".'.format( conn_name))) from qgis.core import QgsDataSourceUri uri = QgsDataSourceUri() settingsList = ["host", "port", "database", "username", "password"] host, port, database, username, password = [ settings.value(x, "", type=str) for x in settingsList ] # get all of the connection options useEstimatedMetadata = settings.value("estimatedMetadata", False, type=bool) uri.setParam('userTablesOnly', str(settings.value("userTablesOnly", False, type=bool))) uri.setParam( 'geometryColumnsOnly', str(settings.value("geometryColumnsOnly", False, type=bool))) uri.setParam( 'allowGeometrylessTables', str(settings.value("allowGeometrylessTables", False, type=bool))) uri.setParam( 'onlyExistingTypes', str(settings.value("onlyExistingTypes", False, type=bool))) uri.setParam( 'includeGeoAttributes', str(settings.value("includeGeoAttributes", False, type=bool))) settings.endGroup() uri.setConnection(host, port, database, username, password) uri.setUseEstimatedMetadata(useEstimatedMetadata) err = u"" try: return self.connectToUri(uri) except ConnectionError as e: err = str(e) # ask for valid credentials max_attempts = 3 for i in range(max_attempts): (ok, username, password) = QgsCredentials.instance().get( uri.connectionInfo(False), username, password, err) if not ok: return False uri.setConnection(host, port, database, username, password) try: self.connectToUri(uri) except ConnectionError as e: if i == max_attempts - 1: # failed the last attempt raise e err = str(e) continue QgsCredentials.instance().put(uri.connectionInfo(False), username, password) return True return False
def __init__(self, host=None, port=None, dbname=None, user=None, passwd=None, service=None, uri=None): # Regular expression for identifiers without need to quote them self.re_ident_ok = re.compile(r"^\w+$") port = str(port) if uri: self.uri = uri else: self.uri = QgsDataSourceUri() if service: self.uri.setConnection(service, dbname, user, passwd) else: self.uri.setConnection(host, port, dbname, user, passwd) conninfo = self.uri.connectionInfo(False) err = None for i in range(4): expandedConnInfo = self.uri.connectionInfo(True) try: self.con = psycopg2.connect(expandedConnInfo) if err is not None: QgsCredentials.instance().put(conninfo, self.uri.username(), self.uri.password()) break except psycopg2.OperationalError as e: if i == 3: raise DbError(str(e)) err = str(e) user = self.uri.username() password = self.uri.password() (ok, user, password) = QgsCredentials.instance().get( conninfo, user, password, err) if not ok: raise DbError( QCoreApplication.translate("PostGIS", 'Action canceled by user')) if user: self.uri.setUsername(user) if password: self.uri.setPassword(password) finally: # remove certs (if any) of the expanded connectionInfo expandedUri = QgsDataSourceUri(expandedConnInfo) sslCertFile = expandedUri.param("sslcert") if sslCertFile: sslCertFile = sslCertFile.replace("'", "") os.remove(sslCertFile) sslKeyFile = expandedUri.param("sslkey") if sslKeyFile: sslKeyFile = sslKeyFile.replace("'", "") os.remove(sslKeyFile) sslCAFile = expandedUri.param("sslrootcert") if sslCAFile: sslCAFile = sslCAFile.replace("'", "") os.remove(sslCAFile) self.has_postgis = self.check_postgis()
def load_config(dir_file_conf): """ Return the json configuration of the control. """ with open(dir_file_conf) as json_data: file = json.load(json_data) return file if __name__ == '__main__': args = get_args() params = ' '.join(sys.argv) # start qgis qgs = qgs_init(args.dirqgis) # uri conection db uri = QgsDataSourceUri() uri.setConnection(args.server, str(args.port), args.dbname, args.user, args.password) # load configuration f_config = load_config(args.conf) # initialization of variables l_ind = {} d_feat = {} l_continuity = f_config["continuidad"] fman = init_file_manager(args.output) consignment_geometry = get_geometry_layer(args.rem) l_ind, d_feat = create_indexes(f_config["indices"], uri, args) # iteration of layers to verify control 1, 2, 3
def testCreateRenameDeleteTable(self): connection_name = 'testCreateRenameDeleteTable' plugin = createDbPlugin('gpkg') uri = QgsDataSourceUri() test_gpkg_new = os.path.join(self.basetestpath, 'testCreateRenameDeleteTable.gpkg') shutil.copy(self.test_gpkg, test_gpkg_new) uri.setDatabase(test_gpkg_new) self.assertTrue(plugin.addConnection(connection_name, uri)) connection = createDbPlugin('gpkg', connection_name) connection.connect() db = connection.database() self.assertIsNotNone(db) tables = db.tables() self.assertEqual(len(tables), 1) table = tables[0] self.assertTrue(table.rename('newName')) self.assertEqual(table.name, 'newName') connection.reconnect() db = connection.database() tables = db.tables() self.assertEqual(len(tables), 1) table = tables[0] self.assertEqual(table.name, 'newName') fields = [] geom = ['geometry', 'POINT', 4326, 3] field1 = TableField(table) field1.name = 'fid' field1.dataType = 'INTEGER' field1.notNull = True field1.primaryKey = True field2 = TableField(table) field2.name = 'str_field' field2.dataType = 'TEXT' field2.modifier = 20 fields = [field1, field2] self.assertTrue(db.createVectorTable('newName2', fields, geom)) tables = db.tables() self.assertEqual(len(tables), 2) new_table = tables[1] self.assertEqual(new_table.name, 'newName2') fields = new_table.fields() self.assertEqual(len(fields), 3) self.assertFalse(new_table.hasSpatialIndex()) self.assertTrue(new_table.createSpatialIndex()) self.assertTrue(new_table.hasSpatialIndex()) self.assertTrue(new_table.delete()) tables = db.tables() self.assertEqual(len(tables), 1) connection.remove()
def processAlgorithm(self, context, feedback): database = self.getParameterValue(self.DATABASE) uri = QgsDataSourceUri(database) if uri.database() is '': if '|layerid' in database: database = database[:database.find('|layerid')] uri = QgsDataSourceUri('dbname=\'%s\'' % (database)) db = spatialite.GeoDB(uri) overwrite = self.getParameterValue(self.OVERWRITE) createIndex = self.getParameterValue(self.CREATEINDEX) convertLowerCase = self.getParameterValue(self.LOWERCASE_NAMES) dropStringLength = self.getParameterValue(self.DROP_STRING_LENGTH) forceSinglePart = self.getParameterValue(self.FORCE_SINGLEPART) primaryKeyField = self.getParameterValue(self.PRIMARY_KEY) or 'id' encoding = self.getParameterValue(self.ENCODING) layerUri = self.getParameterValue(self.INPUT) layer = QgsProcessingUtils.mapLayerFromString(layerUri, context) table = self.getParameterValue(self.TABLENAME) if table: table.strip() if not table or table == '': table = layer.name() table = table.replace(' ', '').lower() providerName = 'spatialite' geomColumn = self.getParameterValue(self.GEOMETRY_COLUMN) if not geomColumn: geomColumn = 'the_geom' options = {} if overwrite: options['overwrite'] = True if convertLowerCase: options['lowercaseFieldNames'] = True geomColumn = geomColumn.lower() if dropStringLength: options['dropStringConstraints'] = True if forceSinglePart: options['forceSinglePartGeometryType'] = True # Clear geometry column for non-geometry tables if not layer.hasGeometryType(): geomColumn = None uri = db.uri uri.setDataSource('', table, geomColumn, '', primaryKeyField) if encoding: layer.setProviderEncoding(encoding) (ret, errMsg) = QgsVectorLayerExporter.exportLayer( layer, uri.uri(), providerName, self.crs, False, options, ) if ret != 0: raise GeoAlgorithmExecutionException( self.tr('Error importing to Spatialite\n{0}').format(errMsg)) if geomColumn and createIndex: db.create_spatial_index(table, geomColumn)
def ogrConnectionStringAndFormat(uri, context): """Generates OGR connection string and format string from layer source Returned values are a tuple of the connection string and format string """ ogrstr = None format = None layer = QgsProcessingUtils.mapLayerFromString(uri, context, False) if layer is None: path, ext = os.path.splitext(uri) format = QgsVectorFileWriter.driverForExtension(ext) return '"' + uri + '"', '"' + format + '"' provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get( conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError( 'Could not connect to PostgreSQL database - check connection info' ) if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError( 'Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return '"' + ogrstr + '"', '"' + format + '"'
def addWms(self, wms_name, url, layers, mime_type, epsg_code, protocol): """ # Slot for exposing the same-name function to Javascript. # Adding the WMS to the QGis TOC. :param wms_name: The WMS name to add in TOC as group :type wms_name: str :param url: The WMS URL :type url: str :param layers: The list of the WMS layers to add :type layers: list of str :param mime_type: The image MIME TYPE (e.g. image/png) :type mime_type: str :param epsg_code: The EPSG code (e.g. the number 32632) :type epsg_code: int :param protocol: The protocol (i.e. should be 'ba' for applying basic authentication). Not yet managed. :type protocol: str """ qgs_logger = QgsApplication.messageLog() qgs_logger.logMessage('addWms: wms_name = {}'.format(wms_name), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: url = {}'.format(url), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: layers = {}'.format(layers), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: mime_type = {}'.format(mime_type), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: epsg_code = {}'.format(epsg_code), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('addWms: protocol = {}'.format(protocol), tag=configuration.LOGGER_TAG, level=Qgis.Info) # For storing the URI data uri = QgsDataSourceUri() # Split the host with the request data pieces = url.split("?") if len(pieces) == 1: qgs_logger.logMessage('len(pieces) == 1', tag=configuration.LOGGER_TAG, level=Qgis.Info) elif len(pieces) == 2: qgs_logger.logMessage('len(pieces) == 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) # Overriding the URL url = "{}{}".format(pieces[0], "?") parameters_values = pieces[1].split("=") if len(parameters_values) == 2: qgs_logger.logMessage('len(parameters) == 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) uri.setParam(parameters_values[0], parameters_values[1]) qgs_logger.logMessage('uri.param({}): {}'.format( parameters_values[0], uri.param(parameters_values[0])), tag=configuration.LOGGER_TAG, level=Qgis.Info) else: qgs_logger.logMessage('len(p) != 2', tag=configuration.LOGGER_TAG, level=Qgis.Info) else: qgs_logger.logMessage('len(pieces) > 2 Not yet managed!', tag=configuration.LOGGER_TAG, level=Qgis.Warning) # Setting the URL to the URI uri.setParam("url", url) # Process the layers accordingly if just an element or a list of elements layers_list = [] if "," in layers: layers_list = layers.split(",") else: layers_list.append(layers) # Setting the parameter 'layers' in the URI for val in layers_list: uri.setParam("layers", val) # Setting the other parameters # Styles seems required: https://gis.stackexchange.com/questions/183485/load-wms-with-pyqgis uri.setParam("styles", "") uri.setParam("format", mime_type) uri.setParam("crs", "EPSG:{}".format(epsg_code)) # https://docs.qgis.org/3.4/en/docs/pyqgis_developer_cookbook/loadlayer.html#raster-layers # Ignore GetCoverage URL advertised by GetCapabilities. May be necessary if a server is not configured properly. uri.setParam("IgnoreGetMapUrl", "1") # Adding the parameters for the basic authentication qgs_logger.logMessage('Applying Basic-Authentication', tag=configuration.LOGGER_TAG, level=Qgis.Info) uri.setParam("username", self.session_user) uri.setParam("password", self.session_password) # Logging the parameters for debugging qgs_logger.logMessage('uri.param(url): {}'.format(uri.param("url")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(layers): {}'.format( uri.param("layers")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(format): {}'.format( uri.param("format")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.param(crs): {}'.format(uri.param("crs")), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.service(): {}'.format(uri.service()), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('encodedUri: {}'.format(str(uri.encodedUri())), tag=configuration.LOGGER_TAG, level=Qgis.Info) qgs_logger.logMessage('uri.uri(): {}'.format(uri.uri()), tag=configuration.LOGGER_TAG, level=Qgis.Info) # Generating the WMS layer wms_layer = QgsRasterLayer(str(uri.encodedUri()), wms_name, 'wms') # If the WMS is correctly generated, add to the QGis TOC if wms_layer.isValid(): QgsProject.instance().addMapLayer(wms_layer) else: qgs_logger.logMessage( 'Impossibile aggiungere il WMS: {}'.format(wms_name), tag=configuration.LOGGER_TAG, level=Qgis.Warning) self.show_message( "Attenzione!", "Impossibile aggiungere il WMS " + wms_name + " al progetto")