def _clearSslTempCertsIfAny(self, connectionInfo): # remove certs (if any) of the connectionInfo expandedUri = QgsDataSourceUri(connectionInfo) def removeCert(certFile): certFile = certFile.replace("'", "") file = QFile(certFile) # set permission to allow removing on Win. # On linux and Mac if file is set with QFile::>ReadUser # does not create problem removing certs if not file.setPermissions(QFile.WriteOwner): raise Exception('Cannot change permissions on {}: error code: {}'.format(file.fileName(), file.error())) if not file.remove(): raise Exception('Cannot remove {}: error code: {}'.format(file.fileName(), file.error())) sslCertFile = expandedUri.param("sslcert") if sslCertFile: removeCert(sslCertFile) sslKeyFile = expandedUri.param("sslkey") if sslKeyFile: removeCert(sslKeyFile) sslCAFile = expandedUri.param("sslrootcert") if sslCAFile: removeCert(sslCAFile)
def testWfsSettings(self): uri = QgsDataSourceUri() QgsOwsConnection.addWfsConnectionSettings(uri, 'qgis/connections-wfs/test/') self.assertEqual(uri.param('version'), '1.1.0') self.assertEqual(uri.param('maxNumFeatures'), '47') self.assertEqual(uri.param('IgnoreAxisOrientation'), '1') self.assertEqual(uri.param('InvertAxisOrientation'), '1')
def testWfsSettings(self): uri = QgsDataSourceUri() QgsOwsConnection.addWfsConnectionSettings( uri, 'qgis/connections-wfs/test/') self.assertEqual(uri.param('version'), '1.1.0') self.assertEqual(uri.param('maxNumFeatures'), '47') self.assertEqual(uri.param('IgnoreAxisOrientation'), '1') self.assertEqual(uri.param('InvertAxisOrientation'), '1')
def testWmsSettings(self): uri = QgsDataSourceUri() QgsOwsConnection.addWmsWcsConnectionSettings(uri, 'qgis/connections-wms/test/') self.assertEqual(uri.httpHeader('referer'), 'my_ref') self.assertEqual(uri.param('IgnoreGetMapUrl'), '1') self.assertEqual(uri.param('IgnoreGetFeatureInfoUrl'), '1') self.assertEqual(uri.param('SmoothPixmapTransform'), '1') self.assertEqual(uri.param('dpiMode'), '4') self.assertEqual(uri.param('IgnoreAxisOrientation'), '1') self.assertEqual(uri.param('InvertAxisOrientation'), '1')
def getWFSScriptTag(layer, layerName): 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 scriptTag = re.sub(r'SRSNAME\=EPSG\:\d+', 'SRSNAME=EPSG:4326', layerSource) scriptTag += "&outputFormat=text%2Fjavascript&format_options=callback%3A" scriptTag += "get" + layerName + "Json" return scriptTag
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 testWmsSettings(self): uri = QgsDataSourceUri() QgsOwsConnection.addWmsWcsConnectionSettings(uri, 'qgis/connections-wms/test/') self.assertEqual(uri.param('referer'), 'my_ref') self.assertEqual(uri.param('IgnoreGetMapUrl'), '1') self.assertEqual(uri.param('IgnoreGetFeatureInfoUrl'), '1') self.assertEqual(uri.param('SmoothPixmapTransform'), '1') self.assertEqual(uri.param('dpiMode'), '4') self.assertEqual(uri.param('IgnoreAxisOrientation'), '1') self.assertEqual(uri.param('InvertAxisOrientation'), '1')
def filename(self) -> str: """Returns the filename of the file if the layer is file based. E.g. GPKG, CSV, but not PostGIS, WFS Note: This may return garbage path, e.g. on online layers such as PostGIS or WFS. Always check with os.path.isfile(), as Path.is_file() raises an exception prior to Python 3.8 """ metadata = self.metadata filename = "" if self.layer.type() == QgsMapLayer.VectorTileLayer: uri = QgsDataSourceUri() uri.setEncodedUri(self.layer.source()) return uri.param("url") elif self.layer.dataProvider() is None: return "" filename = metadata.get("path", "") path_resolver = self.project.pathResolver() resolved_filename = path_resolver.writePath(filename) if resolved_filename.startswith("localized:"): return resolved_filename[10:] return filename
def getOgrCompatibleSource(self, parameter_name, parameters, context, feedback, executing): """ Interprets a parameter as an OGR compatible source and layer name :param executing: """ if not executing and parameter_name in parameters and isinstance( parameters[parameter_name], QgsProcessingFeatureSourceDefinition): # if not executing, then we throw away all 'selected features only' settings # since these have no meaning for command line gdal use, and we don't want to force # an export of selected features only to a temporary file just to show the command! parameters = {parameter_name: parameters[parameter_name].source} input_layer = self.parameterAsVectorLayer(parameters, parameter_name, context) ogr_data_path = None ogr_layer_name = None if input_layer is None or input_layer.dataProvider().name( ) == 'memory': if executing: # parameter is not a vector layer - try to convert to a source compatible with OGR # and extract selection if required ogr_data_path = self.parameterAsCompatibleSourceLayerPath( parameters, parameter_name, context, QgsVectorFileWriter.supportedFormatExtensions(), QgsVectorFileWriter.supportedFormatExtensions()[0], feedback=feedback) ogr_layer_name = GdalUtils.ogrLayerName(ogr_data_path) else: #not executing - don't waste time converting incompatible sources, just return dummy strings #for the command preview (since the source isn't compatible with OGR, it has no meaning anyway and can't #be run directly in the command line) ogr_data_path = 'path_to_data_file' ogr_layer_name = 'layer_name' elif input_layer.dataProvider().name() == 'ogr': if executing and (isinstance(parameters[parameter_name], QgsProcessingFeatureSourceDefinition) and parameters[parameter_name].selectedFeaturesOnly) \ or input_layer.subsetString(): # parameter is a vector layer, with OGR data provider # so extract selection if required ogr_data_path = self.parameterAsCompatibleSourceLayerPath( parameters, parameter_name, context, QgsVectorFileWriter.supportedFormatExtensions(), feedback=feedback) parts = QgsProviderRegistry.instance().decodeUri( 'ogr', ogr_data_path) ogr_data_path = parts['path'] if 'layerName' in parts and parts['layerName']: ogr_layer_name = parts['layerName'] else: ogr_layer_name = GdalUtils.ogrLayerName(ogr_data_path) else: #either not using the selection, or #not executing - don't worry about 'selected features only' handling. It has no meaning #for the command line preview since it has no meaning outside of a QGIS session! ogr_data_path = GdalUtils.ogrConnectionStringAndFormatFromLayer( input_layer)[0] ogr_layer_name = GdalUtils.ogrLayerName( input_layer.dataProvider().dataSourceUri()) elif input_layer.dataProvider().name().lower() == 'wfs': uri = QgsDataSourceUri(input_layer.source()) baseUrl = uri.param('url').split('?')[0] ogr_data_path = "WFS:{}".format(baseUrl) ogr_layer_name = uri.param('typename') else: # vector layer, but not OGR - get OGR compatible path # TODO - handle "selected features only" mode!! ogr_data_path = GdalUtils.ogrConnectionStringFromLayer(input_layer) ogr_layer_name = GdalUtils.ogrLayerName( input_layer.dataProvider().dataSourceUri()) return ogr_data_path, ogr_layer_name
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 uri.service() is None: 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.encode('utf-8')) except self.connection_error_types() as e: err = unicode(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.encode('utf-8')) QgsCredentials.instance().put(conninfo, username, password) except self.connection_error_types() as e: if i == 2: raise ConnectionError(e) err = unicode(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 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' elif provider.lower() == "wfs": uri = QgsDataSourceUri(layer.source()) baseUrl = uri.param('url').split('?')[0] ogrstr = "WFS:{}".format(baseUrl) format = 'WFS' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return ogrstr, '"' + format + '"'
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 uri.service() is None: 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.encode('utf-8')) except self.connection_error_types() as e: err = unicode(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.encode('utf-8')) QgsCredentials.instance().put(conninfo, username, password) except self.connection_error_types() as e: if i == 2: raise ConnectionError(e) err = unicode(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 __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 QgsProcessingException(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 QgsProcessingException(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 __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 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")