def get_qgis_proxy_config(url=None):
"""Check if a proxy is enabled and needed for the given url. Return the settings and additional info."""
proxy_config = None
s = QSettings()
proxy_enabled = s.value("proxy/proxyEnabled", False, type=bool)
if proxy_enabled:
proxy_type = s.value("proxy/proxyType")
if proxy_type not in ("HttpProxy", "HttpCachingProxy"):
raise ClientError(
f"Not supported proxy server type ({proxy_type})")
excluded = [
e.rstrip("/")
for e in s.value("proxy/proxyExcludedUrls", "").split("|")
]
if url is not None and url.rstrip("/") in excluded:
return proxy_config
proxy_config = dict()
proxy_config["url"] = s.value("proxy/proxyHost", None)
if proxy_config["url"] is None:
raise ClientError("No URL given for proxy server")
proxy_config["port"] = s.value("proxy/proxyPort", 3128)
auth_conf_id = s.value("proxy/authcfg", None)
if auth_conf_id:
auth_manager = QgsApplication.authManager()
auth_conf = QgsAuthMethodConfig()
auth_manager.loadAuthenticationConfig(auth_conf_id, auth_conf,
True)
proxy_config["user"] = auth_conf.configMap()["username"]
proxy_config["password"] = auth_conf.configMap()["password"]
else:
proxy_config["user"] = s.value("proxy/proxyUser", None)
proxy_config["password"] = s.value("proxy/proxyPassword", None)
return proxy_config
def authenticate(self, reply, auth):
"""
:param reply:
:param auth:
:return:
"""
if not self.connection:
self.report_error("No connection set for authentication!")
reply.abort()
if self.connection.auth_cfg == '':
return
self.report_info('Authenticating connection \'' +
self.connection.name + '\' with auth_cfg \'' +
str(self.connection.auth_cfg) + '\'')
self.auth += 1
if self.auth >= 3:
reply.abort()
config = QgsAuthMethodConfig()
QgsApplication.authManager().loadAuthenticationConfig(
self.connection.auth_cfg, config, True)
if 'username' in config.configMap():
auth.setUser(config.configMap()['username'])
auth.setPassword(config.configMap()['password'])
def sync(model):
"""Syncs the model with the QGIS data base"""
kwargs = {
'signal': post_delete,
'receiver': sync_auth_delete,
'sender': QgisAuth,
'dispatch_uid': None
}
with temp_disconnect_signal(**kwargs):
kwargs = {
'signal': pre_delete,
'receiver': check_layer_dependencies,
'sender': QgisAuth,
'dispatch_uid': None
}
with temp_disconnect_signal(**kwargs):
model._objects.all().delete()
am = QgsApplication.instance().authManager()
kwargs = {
'signal': post_save,
'receiver': sync_auth_save,
'sender': QgisAuth,
'dispatch_uid': None
}
with temp_disconnect_signal(**kwargs):
for authcfg in sorted(am.configIds()):
c = QgsAuthMethodConfig()
am.loadAuthenticationConfig(authcfg, c, True)
model._objects.create(id=c.id(), name=c.name(), config=c.configMap(
), uri=c.uri(), version=c.version(), method=c.method())
def process_put_call(self, url, data=None, report_url=True):
"""
Run a PUT request and return reply data
:param url: url for request
:param data:
:param report_url: True if URL should be reported to feedback
:return: response or error message in json format
"""
if self.connection.read_only:
return {
"error": {
"msg": "Graphium connection is set to read-only!"
}
}
url_query = QUrl(url)
if report_url:
self.report_info('PUT ' + url_query.toString())
data_byte_array = QJsonDocument.fromVariant(data)
request = QNetworkRequest(url_query)
if self.connection.auth_cfg != '':
self.auth = 0
config = QgsAuthMethodConfig()
QgsApplication.authManager().loadAuthenticationConfig(
self.connection.auth_cfg, config, True)
concatenated = config.configMap(
)['username'] + ":" + config.configMap()['password']
data = base64.encodebytes(concatenated.encode("utf-8")).replace(
'\n'.encode("utf-8"), ''.encode("utf-8"))
request.setRawHeader("Authorization".encode("utf-8"),
("Basic %s" % data).encode("utf-8"))
request.setRawHeader("Accept".encode("utf-8"),
"*/*".encode("utf-8"))
loop = QEventLoop() # https://stackoverflow.com/a/46514984
reply = self.network_access_manager.put(request,
data_byte_array.toJson())
reply.finished.connect(loop.quit)
loop.exec_()
return self.process_q_reply(reply)
def get_db_connection_params(plan: LandUsePlanEnum) -> Dict[str, str]:
"""
:return: Psycopg2 connection params for Qaava database
"""
s = QSettings()
s.beginGroup(f"{PG_CONNECTIONS}/{get_qaava_connection_name(plan)}")
auth_cfg_id = parse_value(s.value("authcfg"))
username_saved = parse_value(s.value("saveUsername"))
pwd_saved = parse_value(s.value("savePassword"))
params = {}
for qgs_key, psyc_key in QGS_SETTINGS_PSYCOPG2_PARAM_MAP.items():
params[psyc_key] = parse_value(s.value(qgs_key))
s.endGroup()
# username or password might have to be asked separately
if not username_saved:
params["user"] = None
if not pwd_saved:
params["password"] = None
if auth_cfg_id is not None and auth_cfg_id != "":
LOGGER.debug(f"Auth cfg: {auth_cfg_id}")
# Auth config is being used to store the username and password
auth_config = QgsAuthMethodConfig()
# noinspection PyArgumentList
QgsApplication.authManager().loadAuthenticationConfig(
auth_cfg_id, auth_config, True)
if auth_config.isValid():
params["user"] = auth_config.configMap().get("username")
params["password"] = auth_config.configMap().get("password")
else:
raise QaavaAuthConfigException(
tr("Auth config error occurred while fetching database connection parameters"
),
bar_msg=bar_msg(
tr(f"Check auth config with id: {auth_cfg_id}")))
return params
def process_delete_call(self, url, report_url=True):
"""
Run a DELETE request and return reply data
:param url: url for request
:param report_url: True if URL should be reported to feedback
:return: response or error message in json format
"""
if self.connection.read_only:
return {
"error": {
"msg": "Graphium connection is set to read-only!"
}
}
url_query = QUrl(url)
if report_url:
self.report_info('DELETE ' + url_query.toString())
request = QNetworkRequest(url_query)
if self.connection.auth_cfg != '':
self.auth = 0
config = QgsAuthMethodConfig()
QgsApplication.authManager().loadAuthenticationConfig(
self.connection.auth_cfg, config, True)
concatenated = config.configMap(
)['username'] + ":" + config.configMap()['password']
data = base64.encodebytes(concatenated.encode("utf-8")).replace(
'\n'.encode("utf-8"), ''.encode("utf-8"))
request.setRawHeader("Authorization".encode("utf-8"),
("Basic %s" % data).encode("utf-8"))
request.setRawHeader("Accept".encode("utf-8"),
"*/*".encode("utf-8"))
loop = QEventLoop()
reply = self.network_access_manager.deleteResource(request)
reply.finished.connect(loop.quit)
loop.exec_()
return self.process_q_reply(reply)
def readDatabaseParamsFromSettings(self, usedDatabaseConnectionName):
settings = QSettings()
settings.beginGroup(YleiskaavaSettings.PG_CONNECTIONS + "/" +
usedDatabaseConnectionName)
params = {}
auth_cfg_id = parse_value(settings.value("authcfg"))
username_saved = parse_value(settings.value("saveUsername"))
pwd_saved = parse_value(settings.value("savePassword"))
for qgs_key, psyc_key in YleiskaavaDatabase.QGS_SETTINGS_PSYCOPG2_PARAM_MAP.items(
):
params[psyc_key] = parse_value(settings.value(qgs_key))
settings.endGroup()
# username or password might have to be asked separately
if not username_saved:
params["user"] = None
if not pwd_saved:
params["password"] = None
if auth_cfg_id is not None and auth_cfg_id != "":
# LOGGER.info(f"Auth cfg: {auth_cfg_id}")
# Auth config is being used to store the username and password
auth_config = QgsAuthMethodConfig()
authMgr = QgsApplication.authManager()
authMgr.loadAuthenticationConfig(auth_cfg_id, auth_config, True)
if auth_config.isValid():
params["user"] = auth_config.configMap().get("username")
params["password"] = auth_config.configMap().get("password")
else:
raise QaavaAuthConfigException()
# LOGGER.info(f"PR{params} {username_saved} {pwd_saved}")
return params
def get_authconfig_map(authconfigid):
# to get username and password from the authconfig
auth_mgr = QgsApplication.authManager()
auth_cfg = QgsAuthMethodConfig()
auth_mgr.loadAuthenticationConfig(authconfigid, auth_cfg, True)
return auth_cfg.configMap()
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())
