def testSetupProxy(self):
"""Test proxy setup"""
settings = QgsSettings()
settings.setValue("proxy/proxyEnabled", True)
settings.setValue("proxy/proxyPort", '1234')
settings.setValue("proxy/proxyHost", 'myproxyhostname.com')
settings.setValue("proxy/proxyUser", 'username')
settings.setValue("proxy/proxyPassword", 'password')
settings.setValue("proxy/proxyExcludedUrls", "http://www.myhost.com|http://www.myotherhost.com")
QgsNetworkAccessManager.instance().setupDefaultProxyAndCache()
vl = QgsVectorLayer(TEST_DATA_DIR + '/' + 'lines.shp', 'proxy_test', 'ogr')
self.assertTrue(vl.isValid())
self.assertEqual(gdal.GetConfigOption("GDAL_HTTP_PROXY"), "myproxyhostname.com:1234")
self.assertEqual(gdal.GetConfigOption("GDAL_HTTP_PROXYUSERPWD"), "username:password")
settings.setValue("proxy/proxyEnabled", True)
settings.remove("proxy/proxyPort")
settings.setValue("proxy/proxyHost", 'myproxyhostname.com')
settings.setValue("proxy/proxyUser", 'username')
settings.remove("proxy/proxyPassword")
settings.setValue("proxy/proxyExcludedUrls", "http://www.myhost.com|http://www.myotherhost.com")
QgsNetworkAccessManager.instance().setupDefaultProxyAndCache()
vl = QgsVectorLayer(TEST_DATA_DIR + '/' + 'lines.shp', 'proxy_test', 'ogr')
self.assertTrue(vl.isValid())
self.assertEqual(gdal.GetConfigOption("GDAL_HTTP_PROXY"), "myproxyhostname.com")
self.assertEqual(gdal.GetConfigOption("GDAL_HTTP_PROXYUSERPWD"), "username")
def __sync_request(self, url):
_url = QUrl(url)
_request = QNetworkRequest(_url)
self.__replies.append(_request)
QgsNetworkAccessManager.instance().sslErrors.connect(self.__supress_ssl_errors)
_reply = QgsNetworkAccessManager.instance().get(_request)
# wait
loop = QEventLoop()
_reply.finished.connect(loop.quit)
loop.exec_()
_reply.finished.disconnect(loop.quit)
QgsNetworkAccessManager.instance().sslErrors.disconnect(self.__supress_ssl_errors)
loop = None
error = _reply.error()
if error != QNetworkReply.NoError:
raise Exception(error)
result_code = _reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
result = _reply.readAll()
self.__replies.append(_reply)
_reply.deleteLater()
if result_code in [301, 302, 307]:
redirect_url = _reply.attribute(QNetworkRequest.RedirectionTargetAttribute)
return self.__sync_request(redirect_url)
else:
return result
def DownLoadOverQT (dlURL, LokFileName):
# QGIS3: funktioniert unter QGIS 3.x recht zuverlässig auch auf "eingeschränktem Rechner"
# - nutzt die Proxyeinstellungen von QGIS
# - funktioniert in QGIS selbst auch über HTTPS (es wird durch QGIS eiun Abfragefenster geöffnet)
# - bei extrem großen Dateien (z.B. 500MBYte) crasht es bei ReadAll()
# QGIS2: funktioniert unter QGIS 2.x innerhalb von QGIS aktuell recht zuverlässig auch auf "eingeschränktem Rechner"
# außerhalb hängt sich der Code auf "eingeschräktem Rechner" auf und bringt dann auch kein Ergebnis
# Normalrechner funktioniert es
def WriteFile(LokFileName, content):
# 1. Ziel löschen, wenn existent
if path.exists(LokFileName):
remove (LokFileName)
out=open(LokFileName,'wb')
out.write(content)
out.close()
def onfinish():
WriteFile(LokFileName,reply.readAll());
loop.quit()
# 2. Download
request = QNetworkRequest()
request.setUrl(QUrl(dlURL))
manager = QgsNetworkAccessManager.instance()
reply = manager.get(request)
reply.setParent(None)
loop = QEventLoop()
reply.finished.connect(onfinish)
loop.exec_()
# Wiederholung bei redirekt (13.08.18 Thüringen leitet an HTTPS weiter)
status=reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
if (status==301):
redirectUrl = reply.attribute(request.RedirectionTargetAttribute)
request = QNetworkRequest()
request.setUrl(redirectUrl)
manager = QgsNetworkAccessManager.instance()
reply = manager.get(request)
reply.setParent(None)
loop = QEventLoop()
reply.finished.connect(onfinish)
loop.exec_()
if path.exists(LokFileName):
return path.getsize(LokFileName), reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
else:
return None, reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
reply.deleteLater()
def sendVote(self, plugin_id, vote):
""" send vote via the RPC """
if not plugin_id or not vote:
return False
url = "http://plugins.qgis.org/plugins/RPC2/"
params = {"id": "djangorpc", "method": "plugin.vote", "params": [str(plugin_id), str(vote)]}
req = QNetworkRequest(QUrl(url))
req.setRawHeader(b"Content-Type", b"application/json")
QgsNetworkAccessManager.instance().post(req, bytes(json.dumps(params), "utf-8"))
return True
def sendVote(self, plugin_id, vote):
""" send vote via the RPC """
if not plugin_id or not vote:
return False
url = "http://plugins.qgis.org/plugins/RPC2/"
params = "{\"id\":\"djangorpc\",\"method\":\"plugin.vote\",\"params\":[%s,%s]}" % (str(plugin_id), str(vote))
req = QNetworkRequest(QUrl(url))
req.setRawHeader("Content-Type", "application/json")
QgsNetworkAccessManager.instance().post(req, params)
return True
def executeRequest (self, url, callback, post = None):
self.messageBar.clearWidgets()
self.cmbOfferings.setEnabled (False)
self.tabWidget.setEnabled (False)
if post:
request = QNetworkRequest(url)
request.setRawHeader('Content-Type', 'application/xml')
self.reply = QgsNetworkAccessManager.instance().post(request,post)
else:
self.reply = QgsNetworkAccessManager.instance().get(QNetworkRequest(url))
progressMessageBar = self.messageBar.createMessage(self.tr("Please wait while downloading"))
progressBar = QtGui.QProgressBar(self)
progressBar.setMinimum(0)
progressBar.setFormat(self.tr("%v bytes downloaded!"))
progressBar.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
def updateProgress (read, total):
try:
progressBar.setMaximum (total)
progressBar.setValue (read)
except: pass
updateProgress (0,0)
self.reply.downloadProgress.connect (updateProgress)
progressMessageBar.layout().addWidget(progressBar)
btnAbort = QtGui.QPushButton(self.tr("Abort"))
btnAbort.clicked.connect(self.reply.abort)
progressMessageBar.layout().addWidget(btnAbort)
fd, replyFilename = mkstemp(suffix=".xml", prefix = callback.__name__, dir = self.selectedWorkDir())
os.close(fd)
replyFile = open (replyFilename, "w")
def replyReadyRead ():
try: replyFile.write (self.reply.readAll())
except: pass
self.reply.readyRead.connect(replyReadyRead)
def finishRequest ():
replyFile.close()
self.cmbOfferings.setEnabled (True)
self.tabWidget.setEnabled(True)
self.messageBar.clearWidgets()
if self.reply.error() != QNetworkReply.NoError:
self.messageBar.pushMessage(self.reply.errorString(), QgsMessageBar.CRITICAL)
else:
callback(replyFilename)
self.reply.deleteLater()
self.reply.finished.connect(finishRequest)
self.messageBar.pushWidget(progressMessageBar, QgsMessageBar.INFO)
def __init__(self, parent=None):
DlgWaiting.__init__(self, parent)
self.safeties = None
self.updatedSafeties = None
self.saved_id = None
self.saved_number = None
self.saved_sopralluoghi = None
self.manager = QgsNetworkAccessManager.instance();
# clean listeners to avoid overlap
try:
self.manager.authenticationRequired.disconnect()
except:
pass
try:
self.manager.finished.disconnect()
except:
pass
# add new listeners
self.manager.authenticationRequired.connect(self.authenticationRequired)
# get connection conf
settings = QSettings()
self.safetyUrl = settings.value("/rt_geosisma_offline/safetyUrl", "/api/v1/safety/")
self.sopralluoghiUrl = settings.value("/rt_geosisma_offline/sopralluoghiUrl", "/api/v1/sopralluoghi/")
self.baseApiUrl = settings.value("/rt_geosisma_offline/baseApiUrl", "http://geosisma-test.faunalia.it/")
self.teamUrl = settings.value("/rt_geosisma_offline/teamUrl", "/api/v1/team/")
self.requestUrl = settings.value("/rt_geosisma_offline/requestUrl", "/api/v1/request/")
self.attachmentUrl = settings.value("/rt_geosisma_offline/attachmentUrl", "/api/v1/attachment/")
self.staffUrl = settings.value("/rt_geosisma_offline/staffUrl", "/api/v1/staff/")
def __init__(self, server=None, projects_base=''):
super(ProjectUpdater, self).__init__()
self.updatethread = None
self.server = server
self.net = QgsNetworkAccessManager.instance()
self.projects_base = projects_base
self.create_worker()
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
if hasattr(self.leFilter, "setPlaceholderText"):
self.leFilter.setPlaceholderText(self.tr("Search..."))
self.manager = QgsNetworkAccessManager.instance()
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolders()[0]
self.urlBase = "https://raw.githubusercontent.com/qgis/QGIS-Processing/master/models/"
self.icon = QIcon(os.path.join(pluginPath, "images", "model.png"))
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolders()[0]
self.urlBase = "https://raw.githubusercontent.com/qgis/QGIS-Processing/master/scripts/"
self.icon = QIcon(os.path.join(pluginPath, "images", "script.png"))
else:
self.folder = RUtils.RScriptsFolders()[0]
self.urlBase = "https://raw.githubusercontent.com/qgis/QGIS-Processing/master/rscripts/"
self.icon = QIcon(os.path.join(pluginPath, "images", "r.svg"))
self.lastSelectedItem = None
self.updateProvider = False
self.data = None
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
self.leFilter.textChanged.connect(self.fillTree)
def __init__(self, url, auth_cfg=None):
self._network_manager = QgsNetworkAccessManager.instance()
self._network_finished = False
self._network_timeout = False
self._url = url
self._auth_cfg = auth_cfg
self._content = None
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
authcfg = repositories.all()[plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, basestring):
if not QgsAuthManager.instance().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def requestFetching(self, key, url=None, redirectionCounter=0):
""" start fetching the repository given by key """
self.mRepositories[key]["state"] = 1
if not url:
url = QUrl(self.mRepositories[key]["url"] + self.urlParams())
# v=str(Qgis.QGIS_VERSION_INT)
# url.addQueryItem('qgis', '.'.join([str(int(s)) for s in [v[0], v[1:3]]]) ) # don't include the bugfix version!
self.mRepositories[key]["QRequest"] = QNetworkRequest(url)
authcfg = self.mRepositories[key]["authcfg"]
if authcfg and isinstance(authcfg, str):
if not QgsApplication.authManager().updateNetworkRequest(
self.mRepositories[key]["QRequest"], authcfg.strip()):
msg = QCoreApplication.translate(
"QgsPluginInstaller",
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
iface.pluginManagerInterface().pushMessage(msg, Qgis.Warning)
self.mRepositories[key]["QRequest"] = None
return
self.mRepositories[key]["QRequest"].setAttribute(QNetworkRequest.User, key)
self.mRepositories[key]["xmlData"] = QgsNetworkAccessManager.instance().get(self.mRepositories[key]["QRequest"])
self.mRepositories[key]["xmlData"].setProperty('reposName', key)
self.mRepositories[key]["xmlData"].setProperty('redirectionCounter', redirectionCounter)
self.mRepositories[key]["xmlData"].downloadProgress.connect(self.mRepositories[key]["Relay"].dataReadProgress)
self.mRepositories[key]["xmlData"].finished.connect(self.xmlDownloaded)
def search(url, callback):
QgsMessageLog.logMessage("URL:" + url, "Gazetteer")
def requestFinished(reply):
# Disconnect from the signal
networkAccessManager = QgsNetworkAccessManager.instance()
networkAccessManager.finished.disconnect(requestFinished)
# Handle the reply
if reply.error() != QNetworkReply.NoError:
QgsMessageLog.logMessage("Network error #{0}: {1}".format(reply.error(), reply.errorString()), "Gazetteer")
callback(u'')
else:
charset = 'UTF-8'
try:
_, params = cgi.parse_header(reply.header(QNetworkRequest.ContentTypeHeader))
charset = params['charset']
except:
pass
QgsMessageLog.logMessage("charset: " + charset, "Gazetteer")
data = unicode(reply.readAll(), charset)
reply.deleteLater()
callback(data)
networkAccessManager = QgsNetworkAccessManager.instance()
networkAccessManager.finished.connect(requestFinished)
networkAccessManager.get(QNetworkRequest(QUrl(QUrl.fromPercentEncoding(url))))
def _getProxySettings(self):
self.proxyEnabled = self.proxyHost = self.proxyPort = self.proxyUser = self.proxyPassword = None
self.proxyUrl = ""
proxyEnabled = self.s.value("proxy/proxyEnabled", "")
if proxyEnabled == 1 or proxyEnabled == "true":
self.proxyEnabled = True
self.proxy_type = self.s.value("proxy/proxyType", "")
self.proxyHost = self.s.value("proxy/proxyHost", "" )
self.proxyPort = self.s.value("proxy/proxyPort", "" )
self.proxyUser = self.s.value("proxy/proxyUser", "" )
self.proxyPassword = self.s.value("proxy/proxyPassword", "" )
if self.proxy_type == "DefaultProxy":
proxies = urllib.request.getproxies()
if len(proxies) == 0:
qgsNetMan = QgsNetworkAccessManager.instance()
proxy = qgsNetMan.proxy().applicationProxy()
self.proxyHost = proxy.hostName()
self.proxyPort = str(proxy.port())
self.proxyUser = proxy.user()
self.proxyPassword = proxy.password()
elif len(proxies) > 0 and 'http' in list(proxies.keys()):
self.proxyUrl = proxies['http']
self.proxyUrlS = proxies['https']
else:
self.proxyUrl = "http://"
if self.proxyUser and self.proxyPassword:
self.proxyUrl += self.proxyUser + ':' + self.proxyPassword + '@'
self.proxyUrl += self.proxyHost + ':' + self.proxyPort
self.proxyUrlS = self.proxyUrl.replace("http://", "https://")
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
self.manager = QgsNetworkAccessManager.instance()
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolder()
self.urlBase = 'https://raw.githubusercontent.com/qgis/QGIS-Processing/master/models/'
self.icon = QIcon(os.path.join(pluginPath, 'images', 'model.png'))
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolder()
self.urlBase = 'https://raw.githubusercontent.com/qgis/QGIS-Processing/master/scripts/'
self.icon = QIcon(os.path.join(pluginPath, 'images', 'script.png'))
else:
self.folder = RUtils.RScriptsFolder()
self.urlBase = 'https://raw.githubusercontent.com/qgis/QGIS-Processing/master/rscripts/'
self.icon = QIcon(os.path.join(pluginPath, 'images', 'r.png'))
self.lastSelectedItem = None
self.updateToolbox = False
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
def __init__(self, config):
# init superclass, needed for Threading
QObject.__init__(self)
if not isinstance(config, ProviderConfig):
raise TypeError('Provider expected a Provider specific Config, got a {} instead'.format(type(config)))
self.config = config
if self.config.url is None:
raise TypeError('url in config is None')
elif self.config.url == '' or len(self.config.url) < 10:
raise TypeError('url in config is empty or too short to be true')
elif not (self.config.url.startswith('file://')
or self.config.url.startswith('http://')
or self.config.url.startswith('https://')):
raise TypeError(
'url should start with: file://, http:// or https://, but starts with %s' % self.config.url[:8])
self.network_manager = QgsNetworkAccessManager.instance()
# while this provider is not ready, keep processing Qt events!!
self.ready = False
# data will always be a list of something, so do 'iter(data)' if you want to iterate over the items
self.data = None
def __init__(self, url, output_path, progress_dialog=None):
"""Constructor of the class.
.. versionchanged:: 3.3 removed manager parameter.
:param url: URL of file.
:type url: str
:param output_path: Output path.
:type output_path: str
:param progress_dialog: Progress dialog widget.
:type progress_dialog: QWidget
"""
# noinspection PyArgumentList
self.manager = QgsNetworkAccessManager.instance()
self.url = QUrl(url)
self.output_path = output_path
self.progress_dialog = progress_dialog
if self.progress_dialog:
self.prefix_text = self.progress_dialog.labelText()
self.output_file = None
self.reply = None
self.downloaded_file_buffer = None
self.finished_flag = False
def executeProcess(self, processUrl, requestXml):
self._processExecuted = False
self.noFilesToFetch = 0
postData = QByteArray()
postData.append(requestXml)
scheme = processUrl.scheme()
path = processUrl.path()
server = processUrl.host()
port = processUrl.port()
processUrl.removeQueryItem('Request')
processUrl.removeQueryItem('identifier')
processUrl.removeQueryItem('Version')
processUrl.removeQueryItem('Service')
qDebug("Post URL=" + pystring(processUrl))
thePostHttp = QgsNetworkAccessManager.instance()
request = QNetworkRequest(processUrl)
request.setHeader( QNetworkRequest.ContentTypeHeader, "text/xml" )
#qDebug("Post REQUEST=" + pystring(postData))
self.thePostReply = thePostHttp.post(request, postData)
self.thePostReply.finished.connect(partial(self.resultHandler, self.thePostReply) )
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
if hasattr(self.leFilter, 'setPlaceholderText'):
self.leFilter.setPlaceholderText(self.tr('Search...'))
self.manager = QgsNetworkAccessManager.instance()
repoUrl = ProcessingConfig.getSetting(ProcessingConfig.MODELS_SCRIPTS_REPO)
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolders()[0]
self.urlBase = '{}/models/'.format(repoUrl)
self.icon = QgsApplication.getThemeIcon("/processingModel.svg")
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolders()[0]
self.urlBase = '{}/scripts/'.format(repoUrl)
self.icon = QgsApplication.getThemeIcon("/processingScript.svg")
self.lastSelectedItem = None
self.updateProvider = False
self.data = None
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
self.leFilter.textChanged.connect(self.fillTree)
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
self.manager = QgsNetworkAccessManager.instance()
repoUrl = ProcessingConfig.getSetting(ProcessingConfig.MODELS_SCRIPTS_REPO)
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolders()[0]
self.urlBase = '{}/models/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'model.png'))
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolders()[0]
self.urlBase = '{}/scripts/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'script.png'))
else:
self.folder = RUtils.RScriptsFolders()[0]
self.urlBase = '{}/rscripts/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'r.svg'))
self.lastSelectedItem = None
self.updateProvider = False
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
def get_qgis_proxy(cls):
s = cls.get_settings()
proxy_enabled = s.value("proxy/proxyEnabled", u"", type=unicode)
proxy_type = s.value("proxy/proxyType", u"", type=unicode)
proxy_host = s.value("proxy/proxyHost", u"", type=unicode)
proxy_port = s.value("proxy/proxyPort", u"", type=unicode)
proxy_user = s.value("proxy/proxyUser", u"", type=unicode)
proxy_password = s.value("proxy/proxyPassword", u"", type=unicode)
if proxy_enabled == "true":
if proxy_type == "DefaultProxy":
qgsNetMan = QgsNetworkAccessManager.instance()
proxy = qgsNetMan.proxy().applicationProxy()
proxy_host = proxy.hostName()
proxy_port = str(proxy.port())
proxy_user = proxy.user()
proxy_password = proxy.password()
if proxy_type in ["DefaultProxy", "Socks5Proxy", "HttpProxy", "HttpCachingProxy"]:
return (
proxy_host,
proxy_port,
proxy_user,
proxy_password
)
return ("", "", "", "")
def __init__(self, alg):
super(AlgorithmDialogBase, self).__init__(iface.mainWindow())
self.setupUi(self)
self.settings = QSettings()
self.restoreGeometry(self.settings.value("/Processing/dialogBase", QByteArray()))
self.executed = False
self.mainWidget = None
self.alg = alg
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.setWindowTitle(AlgorithmClassification.getDisplayName(self.alg))
desktop = QDesktopWidget()
if desktop.physicalDpiX() > 96:
self.textHelp.setZoomFactor(desktop.physicalDpiX() / 96)
algHelp = self.alg.shortHelp()
if algHelp is None:
self.textShortHelp.setVisible(False)
else:
self.textShortHelp.document().setDefaultStyleSheet('''.summary { margin-left: 10px; margin-right: 10px; }
h2 { color: #555555; padding-bottom: 15px; }
a { text-decoration: none; color: #3498db; font-weight: bold; }
p { color: #666666; }
b { color: #333333; }
dl dd { margin-bottom: 5px; }''')
self.textShortHelp.setHtml(algHelp)
self.textShortHelp.setOpenLinks(False)
def linkClicked(url):
webbrowser.open(url.toString())
self.textShortHelp.anchorClicked.connect(linkClicked)
self.textHelp.page().setNetworkAccessManager(QgsNetworkAccessManager.instance())
isText, algHelp = self.alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
try:
if isText:
self.textHelp.setHtml(algHelp)
else:
self.textHelp.settings().clearMemoryCaches()
self.textHelp.load(algHelp)
except:
self.tabWidget.removeTab(2)
else:
self.tabWidget.removeTab(2)
self.showDebug = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_DEBUG_IN_DIALOG)
def replyFinished(self):
reply = self.sender()
url = reply.request().url().toString()
self.log("replyFinished: %s" % url)
if not url in self.fetchedFiles:
self.fetchedFiles[url] = None
self.requestingUrls.remove(url)
self.replies.remove(reply)
isFromCache = 0
httpStatusCode = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
if reply.error() == QNetworkReply.NoError:
self.fetchSuccesses += 1
if reply.attribute(QNetworkRequest.SourceIsFromCacheAttribute):
self.cacheHits += 1
isFromCache = 1
elif not reply.hasRawHeader("Cache-Control"):
cache = QgsNetworkAccessManager.instance().cache()
if cache:
metadata = cache.metaData(reply.request().url())
# self.log("Expiration date: " + metadata.expirationDate().toString().encode("utf-8"))
if metadata.expirationDate().isNull():
metadata.setExpirationDate(
QDateTime.currentDateTime().addSecs(self.DEFAULT_CACHE_EXPIRATION * 60 * 60)
)
cache.updateMetaData(metadata)
self.log(
"Default expiration date has been set: %s (%d h)" % (url, self.DEFAULT_CACHE_EXPIRATION)
)
if reply.isReadable():
data = reply.readAll()
self.fetchedFiles[url] = data
else:
qDebug("http status code: " + str(httpStatusCode))
else:
if self.sync and httpStatusCode == 404:
self.fetchedFiles[url] = self.NOT_FOUND
self.fetchErrors += 1
if self.errorStatus == self.NO_ERROR:
self.errorStatus = self.UNKNOWN_ERROR
self.emit(SIGNAL("replyFinished(QString, int, int)"), url, reply.error(), isFromCache)
reply.deleteLater()
if debug_mode:
qDebug("queue: %d, requesting: %d" % (len(self.queue), len(self.requestingUrls)))
if len(self.queue) + len(self.requestingUrls) == 0:
# all replies have been received
if self.sync:
self.logT("eventLoop.quit()")
self.eventLoop.quit()
else:
self.timer.stop()
elif len(self.queue) > 0:
# start fetching the next file
self.fetchNext()
self.log("replyFinished End: %s" % url)
def __init__(self, alg):
super(AlgorithmDialogBase, self).__init__(iface.mainWindow())
self.setupUi(self)
self.settings = QSettings()
self.restoreGeometry(self.settings.value("/Processing/dialogBase", QByteArray()))
self.executed = False
self.mainWidget = None
self.alg = alg
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.setWindowTitle(self.alg.displayName())
# ~ desktop = QDesktopWidget()
# ~ if desktop.physicalDpiX() > 96:
# ~ self.txtHelp.setZoomFactor(desktop.physicalDpiX() / 96)
algHelp = self.alg.shortHelp()
if algHelp is None:
self.textShortHelp.setVisible(False)
else:
self.textShortHelp.document().setDefaultStyleSheet('''.summary { margin-left: 10px; margin-right: 10px; }
h2 { color: #555555; padding-bottom: 15px; }
a { text-decoration: none; color: #3498db; font-weight: bold; }
p { color: #666666; }
b { color: #333333; }
dl dd { margin-bottom: 5px; }''')
self.textShortHelp.setHtml(algHelp)
self.textShortHelp.setOpenLinks(False)
def linkClicked(url):
webbrowser.open(url.toString())
self.textShortHelp.anchorClicked.connect(linkClicked)
isText, algHelp = self.alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
try:
if isText:
self.txtHelp.setHtml(algHelp)
else:
html = self.tr('<p>Downloading algorithm help... Please wait.</p>')
self.txtHelp.setHtml(html)
rq = QNetworkRequest(algHelp)
self.reply = QgsNetworkAccessManager.instance().get(rq)
self.reply.finished.connect(self.requestFinished)
except Exception, e:
self.tabWidget.removeTab(2)
def fetchResult(self, encoding, schema, fileLink, identifier):
self.noFilesToFetch += 1
url = QUrl(fileLink)
self.myHttp = QgsNetworkAccessManager.instance()
self.theReply = self.myHttp.get(QNetworkRequest(url))
self.emit(SIGNAL("fetchingResult(int)"), self.noFilesToFetch)
# Append encoding to 'finished' signal parameters
self.encoding = encoding
self.schema = schema
self.theReply.finished.connect(partial(self.getResultFile, identifier, self.mimeType, encoding, schema, self.theReply))
def testProxyIsUpdated(self):
"""
Test that proxy is updated
"""
authm = QgsApplication.authManager()
nam = QgsNetworkAccessManager.instance()
proxy = nam.proxy()
self.assertEqual(proxy.password(), '')
self.assertEqual(proxy.user(), '')
self.assertTrue(authm.updateNetworkProxy(proxy, self.auth_config.id()))
self.assertEqual(proxy.user(), self.username)
self.assertEqual(proxy.password(), self.password)
def _replyFinished(self):
reply = self.sender()
url = reply.request().url().toString()
if url not in self.fetchedFiles:
self.fetchedFiles[url] = None
if url in self.requestingReplies:
del self.requestingReplies[url]
httpStatusCode = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
if reply.error() == QNetworkReply.NoError:
self._successes += 1
if reply.attribute(QNetworkRequest.SourceIsFromCacheAttribute):
self._cacheHits += 1
elif not reply.hasRawHeader("Cache-Control"):
cache = QgsNetworkAccessManager.instance().cache()
if cache:
metadata = cache.metaData(reply.request().url())
if metadata.expirationDate().isNull():
metadata.setExpirationDate(QDateTime.currentDateTime().addSecs(self.defaultCacheExpiration * 3600))
cache.updateMetaData(metadata)
self.log("Default expiration date has been set: %s (%d h)" % (url, self.defaultCacheExpiration))
if reply.isReadable():
data = reply.readAll()
self.fetchedFiles[url] = data
else:
qDebug("http status code: " + str(httpStatusCode))
else:
self._errors += 1
if self.errorStatus == self.NO_ERROR:
self.errorStatus = self.UNKNOWN_ERROR
self.replyFinished.emit(url)
reply.deleteLater()
if len(self.queue) + len(self.requestingReplies) == 0:
# all replies have been received
if self.sync:
self.logT("eventLoop.quit()")
self.eventLoop.quit()
else:
self.timer.stop()
self.allRepliesFinished.emit()
elif len(self.queue) > 0:
# start fetching the next file
self.fetchNext()
def requestFetching(self,key):
""" start fetching the repository given by key """
self.mRepositories[key]["state"] = 1
url = QUrl(self.mRepositories[key]["url"] + self.urlParams() )
#v=str(QGis.QGIS_VERSION_INT)
#url.addQueryItem('qgis', '.'.join([str(int(s)) for s in [v[0], v[1:3]]]) ) # don't include the bugfix version!
self.mRepositories[key]["QRequest"] = QNetworkRequest(url)
self.mRepositories[key]["QRequest"].setAttribute( QNetworkRequest.User, key)
self.mRepositories[key]["xmlData"] = QgsNetworkAccessManager.instance().get( self.mRepositories[key]["QRequest"] )
self.mRepositories[key]["xmlData"].setProperty( 'reposName', key)
self.mRepositories[key]["xmlData"].downloadProgress.connect( self.mRepositories[key]["Relay"].dataReadProgress )
self.mRepositories[key]["xmlData"].finished.connect( self.xmlDownloaded )
def fetchNext(self):
if len(self.queue) == 0:
return
url = self.queue.pop(0)
self.log("fetchNext: %s" % url)
request = QNetworkRequest(QUrl(url))
request.setRawHeader("User-Agent", self.userAgent)
reply = QgsNetworkAccessManager.instance().get(request)
reply.finished.connect(self.replyFinishedSlot)
self.requestingUrls.append(url)
self.replies.append(reply)
return reply
def fetchResult(self, encoding, schema, fileLink, identifier, mimeType):
self.noFilesToFetch += 1
url = QUrl(fileLink)
self.myHttp = QgsNetworkAccessManager.instance()
self.theReply = self.myHttp.get(QNetworkRequest(url))
self.fetchingResult.emit(self.noFilesToFetch)
# Append encoding to 'finished' signal parameters
self.encoding = encoding
self.schema = schema
self.theReply.finished.connect(partial(self.getResultFile, identifier, mimeType, encoding, schema, self.theReply))
self.theReply.downloadProgress.connect(lambda done, all, status="download": self.showProgressBar(done, all, status))
def _refresh_contributors(self):
"""
Refreshes the list of contributors from the service
"""
self.edit_contributor_id.clear()
url = SERVICE_MANAGER.get_contributor_endpoint(self.service_type,
self.service_id)
if not url:
return
self.button_refresh_contributors.setEnabled(False)
request = QNetworkRequest(QUrl(url))
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
reply = QgsNetworkAccessManager.instance().get(request)
reply.finished.connect(lambda r=reply: self._reply_finished(r))
def testProxyIsUpdatedByUserSettings(self):
"""
Test that proxy is updated
"""
nam = QgsNetworkAccessManager.instance()
nam.setupDefaultProxyAndCache()
proxy = nam.proxy()
self.assertEqual(proxy.password(), '')
self.assertEqual(proxy.user(), '')
settings = QgsSettings()
settings.setValue("proxy/authcfg", self.auth_config.id())
settings.setValue("proxy/proxyEnabled", True)
del(settings)
nam.setupDefaultProxyAndCache()
proxy = nam.fallbackProxy()
self.assertEqual(proxy.password(), self.password)
self.assertEqual(proxy.user(), self.username)
def requestDownloading(self):
self.request = QNetworkRequest(self.url)
authcfg = repositories.all()[self.plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, str):
if not QgsApplication.authManager().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def json_reply_finished(self):
error = self.reply.error()
if error == QNetworkReply.NoError:
redirect = self.reply.attribute(
QNetworkRequest.RedirectionTargetAttribute)
if redirect is not None and redirect != self.reply.url():
url = self.reply.url()
if redirect.isRelative():
url = self.reply.url().resolved(redirect)
log.debug(f'Redirected to {url.toString()}')
self.reply.deleteLater()
self.reply = None
# noinspection PyArgumentList
self.reply = QgsNetworkAccessManager.instance().get(
QNetworkRequest(url))
self.reply.finished.connect(self.json_reply_finished)
return
status = self.reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
msg = self.reply.attribute(
QNetworkRequest.HttpReasonPhraseAttribute)
log.debug(f'Request finished: {status} - {msg}')
try:
data = bytes(self.reply.readAll())
self.json = json.loads(data)
except Exception as e:
log.debug(str(e))
# noinspection PyUnresolvedReferences
self.finished.emit()
else:
# report any errors except for the one we have caused
# by cancelling the request
if error != QNetworkReply.OperationCanceledError:
msg = f'Network request failed: {self.reply.errorString()}'
log.debug(msg)
# noinspection PyUnresolvedReferences
self.errored.emit(msg)
else:
# noinspection PyUnresolvedReferences
self.aborted.emit()
self.reply.deleteLater()
self.reply = None
def fetchResult(self, encoding, schema, fileLink, identifier):
self.noFilesToFetch += 1
url = QUrl(fileLink)
self.myHttp = QgsNetworkAccessManager.instance()
self.theReply = self.myHttp.get(QNetworkRequest(url))
self.fetchingResult.emit(self.noFilesToFetch)
# Append encoding to 'finished' signal parameters
self.encoding = encoding
self.schema = schema
self.theReply.finished.connect(
partial(self.getResultFile, identifier, self.mimeType, encoding,
schema, self.theReply))
self.theReply.downloadProgress.connect(
lambda done, all, status="download": self.showProgressBar(
done, all, status))
def __init__(self, target, parent = None):
super(internalBrowser, self).__init__(parent)
self.setupUi(self)
self.webView.page().setNetworkAccessManager(QgsNetworkAccessManager.instance())
if target[0:4] == 'http':
self.setWindowTitle('Help')
self.webView.setUrl(QUrl(target))
else:
self.setWindowTitle('Auth')
self.webView.setHtml(target)
self.timer = QTimer()
self.timer.setInterval(500)
self.timer.timeout.connect(self.codeProbe)
self.timer.start()
self.auth_code = None
self.show()
self.raise_()
def __init__(self, alg):
super(AlgorithmDialogBase, self).__init__(iface.mainWindow())
self.setupUi(self)
self.settings = QSettings()
self.restoreGeometry(self.settings.value("/Processing/dialogBase", QByteArray()))
self.executed = False
self.mainWidget = None
self.alg = alg
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.setWindowTitle(AlgorithmClassification.getDisplayName(self.alg))
self.txtHelp.page().setNetworkAccessManager(QgsNetworkAccessManager.instance())
# load algorithm help if available
isText, algHelp = self.alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
else:
algHelp = self.tr('<h2>Sorry, no help is available for this '
'algorithm.</h2>')
try:
if isText:
self.txtHelp.setHtml(algHelp)
else:
self.txtHelp.settings().clearMemoryCaches()
self.tabWidget.setTabText(2, self.tr("Help (loading...)"))
self.tabWidget.setTabEnabled(2, False)
self.txtHelp.loadFinished.connect(self.loadFinished)
self.tabWidget.currentChanged.connect(self.loadHelp)
self.txtHelp.load(algHelp)
self.algHelp = algHelp
except:
self.txtHelp.setHtml(
self.tr('<h2>Could not open help file :-( </h2>'))
self.showDebug = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_DEBUG_IN_DIALOG)
def fetchNext(self):
if len(self.queue) == 0:
return
url = self.queue.pop(0)
self.log("fetchNext: %s" % url)
# create request
request = QNetworkRequest(QUrl(url))
if self.userAgent:
request.setRawHeader(
"User-Agent", self.userAgent
) # will be overwritten in QgsNetworkAccessManager::createRequest() since 2.2
# send request
reply = QgsNetworkAccessManager.instance().get(request)
reply.finished.connect(self._replyFinished)
self.requestingReplies[url] = reply
return reply
def _download_qgis(packageUrl, handle):
from qgis.core import QgsNetworkAccessManager
request = QNetworkRequest(QUrl(packageUrl))
reply = QgsNetworkAccessManager.instance().get(request)
evloop = QEventLoop()
reply.finished.connect(evloop.quit)
evloop.exec_(QEventLoop.ExcludeUserInputEvents)
content_type = reply.rawHeader('Content-Type')
if bytearray(content_type) == bytearray('text/plain; charset=utf-8'):
handle.write(bytearray(reply.readAll()))
else:
msg = 'Failed to download %s\n\nPlease check your QGIS network settings and authentication db' % (
packageUrl)
ret_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
if ret_code:
msg += '\n\nThe HTTP status code was %d.' % (ret_code)
raise Exception(msg)
def downloadBinPackage(packageUrl, destinationFileName):
request = QNetworkRequest(QUrl(packageUrl))
request.setRawHeader('Accept-Encoding', 'gzip,deflate')
reply = QgsNetworkAccessManager.instance().get(request)
evloop = QEventLoop()
reply.finished.connect(evloop.quit)
evloop.exec_(QEventLoop.ExcludeUserInputEvents)
content_type = reply.rawHeader('Content-Type')
if bytearray(content_type) == bytearray('application/zip'):
if os.path.isfile(destinationFileName):
os.unlink(destinationFileName)
destinationFile = open(destinationFileName, 'wb')
destinationFile.write(bytearray(reply.readAll()))
destinationFile.close()
else:
ret_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
raise IOError("{} {}".format(ret_code, packageUrl))
def to_ili2db_args(self):
# Valid ili file, don't pass --modeldir (it can cause ili2db errors)
with_modeldir = not self.ilifile
args = self.base_configuration.to_ili2db_args(with_modeldir=with_modeldir)
proxy = QgsNetworkAccessManager.instance().fallbackProxy()
if proxy.type() == QNetworkProxy.HttpProxy:
args += ["--proxy", proxy.hostName()]
args += ["--proxyPort", str(proxy.port())]
if self.ilimodels:
args += ['--models', self.ilimodels]
if self.tomlfile:
args += ["--iliMetaAttrs", self.tomlfile]
return args
def __init__(self, parentInstance):
super(mapillaryViewer, self).__init__()
self.parentInstance = parentInstance
self.viewport = parentInstance.dlg.webView
#self.viewport.statusBarMessage.connect(self.getJSONmessage)
self.viewport.page().mainFrame().javaScriptWindowObjectCleared.connect(
self.registerJS)
self.locationKey = None
WS = self.viewport.settings()
WS.setAttribute(QWebSettings.JavascriptEnabled, True)
WS.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
WS.setAttribute(QWebSettings.JavascriptCanAccessClipboard, True)
WS.setAttribute(QWebSettings.PrintElementBackgrounds, True)
WS.setAttribute(QWebSettings.OfflineStorageDatabaseEnabled, True)
WS.setAttribute(QWebSettings.LocalStorageEnabled, True)
WS.setAttribute(QWebSettings.PluginsEnabled, True)
WS.setAttribute(QWebSettings.WebGLEnabled, True)
self.viewport.page().setNetworkAccessManager(
QgsNetworkAccessManager.instance())
self.mly_api = mapillaryApi()
self.page = os.path.join(os.path.dirname(__file__), 'res',
'browser.html')
self.openLocation('')
self.enabled = True
proxy_conf = getProxySettings()
if proxy_conf:
proxy = QNetworkProxy()
if proxy_conf['type'] == "DefaultProxy":
proxy.setType(QNetworkProxy.DefaultProxy)
elif proxy_conf['type'] == "Socks5Proxy":
proxy.setType(QNetworkProxy.Socks5Proxy)
elif proxy_conf['type'] == "HttpProxy":
proxy.setType(QNetworkProxy.HttpProxy)
elif proxy_conf['type'] == "HttpCachingProxy":
proxy.setType(QNetworkProxy.HttpCachingProxy)
elif proxy_conf['type'] == "FtpCachingProxy":
proxy.setType(QNetworkProxy.FtpCachingProxy)
proxy.setHostName(proxy_conf['host'])
proxy.setPort(int(proxy_conf['port']))
proxy.setUser(proxy_conf['user'])
proxy.setPassword(proxy_conf['password'])
QNetworkProxy.setApplicationProxy(proxy)
def _sync_get(url):
global __network_manager
if __network_manager is None:
__network_manager = QNetworkAccessManager()
__network_manager.setProxy(QgsNetworkAccessManager.instance().proxy())
pause = QEventLoop()
req = QNetworkRequest(url)
req.setRawHeader(b"Accept", b"application/xml")
req.setRawHeader(b"Accept-Language", b"fr")
reply = __network_manager.get(req)
reply.finished.connect(pause.quit)
is_ok = [True]
def onError(self):
is_ok[0] = False
pause.quit()
reply.error.connect(onError)
pause.exec_()
return reply, is_ok[0]
def requestDescribeProcess(self):
"""
Request process description
"""
self._requestExecuted = False
self.doc = None
self.inputs = []
self.outputs = []
url = self.requestUrl()
myHttp = QgsNetworkAccessManager.instance()
request = QNetworkRequest(url)
# add cookies in header
serverCookie = WpsServerCookie(url)
if serverCookie.checkServerCookies():
request.setRawHeader("Cookie", serverCookie.getServerCookies())
self._theReply = myHttp.get(request)
self._theReply.finished.connect(self._describeProcessFinished)
def run(self):
"""
Executes the custom plugin functionality.
This method is called by the previously defined QAction object (callback),
which went into the toolbar icon and the menu entry.
"""
if self.dockwidget is None:
self.dockwidget = DockCbers4aDownloader()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)
self.dockwidget.visibilityChanged.connect(self.visibility_changed)
self.init()
self.dockwidget.show()
webPage = self.dockwidget.webView.page()
webPage.setNetworkAccessManager(QgsNetworkAccessManager.instance())
else:
if self.dockwidget.isVisible():
self.dockwidget.footprint.setChecked(False)
self.footprint.hide()
self.dockwidget.hide()
else:
self.dockwidget.show()
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = os.path.join(self.plugin_dir,'res','icon.png')
self.mainAction = self.add_action(
icon_path,
text=self.tr(u'go2mapillary'),
callback=self.run,
checkable=True,
parent=self.iface.mainWindow())
self.dlg = go2mapillaryDockWidget()
self.dockwidget=QDockWidget("go2mapillary" , self.iface.mainWindow() )
self.dockwidget.setObjectName("go2mapillary")
self.dockwidget.setWidget(self.dlg)
self.dockwidget.visibilityChanged.connect(self.mlyDockwidgetvisibilityChanged)
self.dlg.webView.page().setNetworkAccessManager(QgsNetworkAccessManager.instance())
self.dlg.webView.page().mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.dlg.webView.page().mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.canvas.mapToolSet.connect(self.toggleViewer)
self.viewer = mapillaryViewer(self)
self.viewer.messageArrived.connect(self.viewerConnection)
self.viewer.openFilter.connect(self.filter_images_func)
#QgsExpressionContextUtils.setGlobalVariable( "mapillaryCurrentKey","noKey")
QgsExpressionContextUtils.removeGlobalVariable("mapillaryCurrentKey")
self.mapSelectionTool = None
self.coverage = mapillary_coverage(self)
self.filterDialog = mapillaryFilter(self)
self.filterAction_images = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow())
self.filterAction_sequences = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow())
self.filterAction_overview = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow())
self.filterAction_images.triggered.connect(self.filter_images_func)
self.filterAction_sequences.triggered.connect(self.filter_sequences_func)
self.filterAction_overview.triggered.connect(self.filter_overview_func)
self.sample_cursor = mapillary_cursor(self)
self.sample_settings = mapillarySettings(self)
self.sample_cursor.update_ds(self.sample_settings.settings['sample_source'])
self.samples_form = mapillaryForm(self)
self.iface.projectRead.connect(self.removeMapillaryLayerGroup)
def _post_data(url: str,
data_: typing.Dict,
network_manager: QgsNetworkAccessManager,
auth_config: str,
feedback: typing.Optional[QgsFeedback] = None):
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json')
reply = network_manager.blockingPost(request,
json.dumps(data_).encode('utf-8'),
auth_config,
True,
feedback=feedback)
status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
raw_string_contents = bytes(reply.content()).decode('utf-8')
if status_code == 201:
result = json.loads(raw_string_contents)
else:
raise QgsProcessingException(f'POST request failed. '
f'status_code: {status_code} - '
f'error_string: {reply.errorString()} - '
f'reply_contents: {raw_string_contents}')
return result
def loadModel(self):
imd = None
try:
loader = ModelLoader(self.ui.mDataLineEdit.text())
models = loader.detect_models()
model_names = map(lambda m: m.name, models)
self._log_output("Looking up models: " + ', '.join(model_names))
ili = loader.gen_lookup_ili()
qDebug(ili)
wpsreq = self._create_wps_request(ili)
url = self.ui.mIlisMetaUrlLineEdit.text()
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader, 'application/xml')
reply = QgsNetworkAccessManager.instance().post(req, wpsreq)
# Wait for reply or timeout
loop = QEventLoop()
reply.finished.connect(loop.quit)
QTimer.singleShot(15000, reply.abort)
loop.exec_()
if reply.isFinished() and reply.error() == QNetworkReply.NoError:
result = reply.readAll()
imd = self._parse_wps_response(result)
except:
qDebug("Exception during IlisModel download")
if imd is None:
self._show_log_window()
QgsApplication.messageLog().logMessage(
"Couldn't download Ilismeta model", "Interlis",
Qgis.MessageLevel(1))
self.ui.mModelLineEdit.setText("")
else:
fh, imdfn = tempfile.mkstemp(suffix='.imd')
os.close(fh)
with codecs.open(imdfn, "w", encoding='utf-8') as file:
file.write(imd)
self.ui.mModelLineEdit.setText(imdfn)
def processAlgorithm(self, parameters, context, feedback):
raw_report = self.parameterAsString(parameters,
REPORT_HANDLER_INPUT_NAME, context)
report = json.loads(raw_report)
auth_config = parse_as_expression(
self.parameterAsExpression(parameters, self.INPUT_AUTH_CONFIG,
context))
base_url = parse_as_expression(
self.parameterAsExpression(parameters,
self.INPUT_DOMINODE_BASE_URL, context))
if not base_url:
raise QgsProcessingException(f'Invalid base_url: {base_url}')
else:
base_url = base_url if base_url.endswith('/') else f'{base_url}/'
feedback.pushInfo(f'report: {report}')
feedback.pushInfo(f'auth_config: {auth_config}')
feedback.pushInfo(f'base_url: {base_url}')
network_manager = QgsNetworkAccessManager.instance()
resource = get_resource(report['dataset'], base_url, network_manager,
feedback)
if resource is None:
resource = post_resource(report['dataset'],
report['dataset_type'],
report['artifact_type'],
base_url,
network_manager=network_manager,
auth_config=auth_config,
feedback=feedback)
feedback.pushInfo(f'resource: {resource}')
validation_report = post_validation_report(report, base_url,
network_manager,
auth_config, feedback)
feedback.pushInfo(f'validation_report: {validation_report}')
return {
self.OUTPUT_RESULT: True,
self.OUTPUT_DOMINODE_RESOURCE_URL: resource['url'],
self.OUTPUT_VALIDATION_REPORT_URL: validation_report['url'],
}
def requestCapabilities(self):
"""
Request server capabilities
"""
self.doc = None
url = QUrl()
if '?' in self.baseUrl:
myRequest = "&Request=GetCapabilities&identifier=&Service=WPS&Version=" + self.version
else:
myRequest = "?Request=GetCapabilities&identifier=&Service=WPS&Version=" + self.version
url.setUrl(self.baseUrl + myRequest)
myHttp = QgsNetworkAccessManager.instance()
request = QNetworkRequest(url)
# add cookies in header
serverCookie = WpsServerCookie(url)
if serverCookie.checkServerCookies():
request.setRawHeader("Cookie", serverCookie.getServerCookies())
self._theReply = myHttp.get(request)
self._theReply.finished.connect(self._capabilitiesRequestFinished)
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def _sendRequest(self, url, params, headers={}):
if self.asynchonous:
if self.reply is not None:
self.reply.finished.disconnect(self.replyFinished)
self.reply.abort()
self.reply = None
url = QUrl(url)
for key, value in params.iteritems():
url.addQueryItem(key, value)
QgsLogger.debug('Request: {}'.format(url.toEncoded()))
request = QNetworkRequest(url)
for key, value in headers.iteritems():
request.setRawHeader(key, value)
self.reply = QgsNetworkAccessManager.instance().get(request)
self.reply.finished.connect(self.replyFinished)
else:
response = urllib2.urlopen(self.url + '?' +
urllib.urlencode(params))
data = json.load(response)
self.loadData(data)
def __init__(self):
# inheritance
super().__init__()
self.tr = object
# API client parameters :
# creds
self.app_id = str
self.app_secret = str
# URL
self.api_url_base = str
self.api_url_auth = str
self.api_url_token = str
self.api_url_redirect = str
# Requesting operation attributes
# manage requesting
self.loopCount = 0
# make request
self.qnam = QgsNetworkAccessManager.instance()
self.token = str
self.currentUrl = str
self.request = object
def get_resource(
name: str,
dominode_base_url: str,
network_manager: QgsNetworkAccessManager,
feedback: typing.Optional[QgsFeedback] = None,
) -> typing.Optional[typing.Dict]:
url_query = QUrlQuery()
url_query.addQueryItem('name', name)
url = QUrl(
f'{dominode_base_url}/dominode-validation/api/dominode-resources/')
url.setQuery(url_query)
request = QNetworkRequest(url)
request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json')
reply = network_manager.blockingGet(request, '', True, feedback=feedback)
status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
result = None
if status_code == 200:
raw_string_contents = bytes(reply.content()).decode('utf-8')
contents = json.loads(raw_string_contents)
exists = contents.get('count', 0) > 0
if exists:
result = contents['results'][0]
return result
def set_proxy_configuration(logger: logging.Logger) -> None:
""" Display proxy configuration
"""
from qgis.PyQt.QtNetwork import QNetworkProxy
from qgis.core import QgsNetworkAccessManager
nam = QgsNetworkAccessManager.instance()
nam.setupDefaultProxyAndCache()
proxy = nam.fallbackProxy()
proxy_type = proxy.type()
if proxy_type == QNetworkProxy.NoProxy:
return
logger.info(
"Proxy configuration enabled: %s:%s, type: %s", proxy.hostName(),
proxy.port(), {
QNetworkProxy.DefaultProxy: 'DefaultProxy',
QNetworkProxy.Socks5Proxy: 'Socks5Proxy',
QNetworkProxy.HttpProxy: 'HttpProxy',
QNetworkProxy.HttpCachingProxy: 'HttpCachingProxy',
QNetworkProxy.HttpCachingProxy: 'FtpCachingProxy',
}.get(proxy_type, 'Undetermined')) # noqa E124
def requestFetching(self, key, url=None, redirectionCounter=0):
""" start fetching the repository given by key """
self.mRepositories[key]["state"] = 1
if not url:
url = QUrl(self.mRepositories[key]["url"] + self.urlParams())
# v=str(Qgis.QGIS_VERSION_INT)
# url.addQueryItem('qgis', '.'.join([str(int(s)) for s in [v[0], v[1:3]]]) ) # don't include the bugfix version!
self.mRepositories[key]["QRequest"] = QNetworkRequest(url)
self.mRepositories[key]["QRequest"].setAttribute(
QNetworkRequest.Attribute(
QgsNetworkRequestParameters.AttributeInitiatorClass), "Relay")
self.mRepositories[key]["QRequest"].setAttribute(
QNetworkRequest.FollowRedirectsAttribute, True)
authcfg = self.mRepositories[key]["authcfg"]
if authcfg and isinstance(authcfg, str):
if not QgsApplication.authManager().updateNetworkRequest(
self.mRepositories[key]["QRequest"], authcfg.strip()):
msg = QCoreApplication.translate(
"QgsPluginInstaller",
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(
authcfg)
iface.pluginManagerInterface().pushMessage(msg, Qgis.Warning)
self.mRepositories[key]["QRequest"] = None
return
self.mRepositories[key]["QRequest"].setAttribute(
QNetworkRequest.User, key)
self.mRepositories[key]["xmlData"] = QgsNetworkAccessManager.instance(
).get(self.mRepositories[key]["QRequest"])
self.mRepositories[key]["xmlData"].setProperty('reposName', key)
self.mRepositories[key]["xmlData"].setProperty('redirectionCounter',
redirectionCounter)
self.mRepositories[key]["xmlData"].downloadProgress.connect(
self.mRepositories[key]["Relay"].dataReadProgress)
self.mRepositories[key]["xmlDataFinished"] = self.mRepositories[key][
"xmlData"].finished.connect(self.xmlDownloaded)
def _sync_get(url):
global __network_manager
if __network_manager is None:
__network_manager = QNetworkAccessManager()
__network_manager.setProxy(QgsNetworkAccessManager.instance().proxy())
pause = QEventLoop()
req = QNetworkRequest(url)
req.setRawHeader(b"Accept", b"application/xml")
req.setRawHeader(b"Accept-Language",
bytes(settings.value("default_language", "fr"), "utf8"))
req.setRawHeader(
b"User-Agent",
bytes(settings.value("http_user_agent", plugin_name()), "utf8"))
reply = __network_manager.get(req)
reply.finished.connect(pause.quit)
is_ok = [True]
def onError(self):
is_ok[0] = False
pause.quit()
reply.error.connect(onError)
pause.exec_()
return reply, is_ok[0]
def __init__(self, layout):
super().__init__(layout)
self.setCacheMode(QGraphicsItem.NoCache)
self.plot_settings = PlotSettings()
self.web_page = LoggingWebPage(self)
self.web_page.setNetworkAccessManager(
QgsNetworkAccessManager.instance())
# This makes the background transparent. (copied from QgsLayoutItemLabel)
palette = self.web_page.palette()
palette.setBrush(QPalette.Base, Qt.transparent)
self.web_page.setPalette(palette)
self.web_page.mainFrame().setZoomFactor(10.0)
self.web_page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self.web_page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
self.web_page.loadFinished.connect(self.loading_html_finished)
self.html_loaded = False
self.html_units_to_layout_units = self.calculate_html_units_to_layout_units(
)
self.sizePositionChanged.connect(self.refresh)
def fetch_missing(self):
# pop first missing origin from front of queue and fetch it
self.message.emit(
self.tr(
'Returned XML was incomplete. {} missing origins left to fetch'
).format(len(self.missing_origins)), Qgis.Warning)
remaining = list(self.missing_origins)
next_origin = remaining[0]
self.missing_origins = set(remaining[1:])
# change smi: prefix to http://
parts = next_origin.split(":")
next_origin = 'http://' + ':'.join(parts[1:])
self.is_missing_origin_request = True
request = QNetworkRequest(QUrl(next_origin))
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
reply = QgsNetworkAccessManager.instance().get(request)
reply.finished.connect(lambda r=reply: self._reply_finished(r))
reply.downloadProgress.connect(self._reply_progress)
def __init__(self, url="http://overpass-api.de/api/", output=None):
"""
Constructor
@param url:URL of OverPass
@type url:str
@param output:Output desired (XML or JSON)
@type output:str
"""
if not url:
url = "http://overpass-api.de/api/"
self.__url = url
self.result_path = None
if output not in (None, "json", "xml"):
raise OutPutFormatException
self.__output = output
self.network = QgsNetworkAccessManager.instance()
self.network_reply = None
self.loop = None