def qute_history(url):
"""Handler for qute://history. Display and serve history."""
if url.path() == '/data':
try:
offset = QUrlQuery(url).queryItemValue("offset")
offset = int(offset) if offset else None
except ValueError as e:
raise QuteSchemeError("Query parameter offset is invalid", e)
# Use start_time in query or current time.
try:
start_time = QUrlQuery(url).queryItemValue("start_time")
start_time = float(start_time) if start_time else time.time()
except ValueError as e:
raise QuteSchemeError("Query parameter start_time is invalid", e)
return 'text/html', json.dumps(history_data(start_time, offset))
else:
if (config.get('content', 'allow-javascript')
and (objects.backend == usertypes.Backend.QtWebEngine
or qtutils.is_qtwebkit_ng())):
return 'text/html', jinja.render('history.html',
title='History',
session_interval=config.get(
'ui',
'history-session-interval'))
else:
# Get current date from query parameter, if not given choose today.
curr_date = datetime.date.today()
try:
query_date = QUrlQuery(url).queryItemValue("date")
if query_date:
curr_date = datetime.datetime.strptime(
query_date, "%Y-%m-%d").date()
except ValueError:
log.misc.debug("Invalid date passed to qute:history: " +
query_date)
one_day = datetime.timedelta(days=1)
next_date = curr_date + one_day
prev_date = curr_date - one_day
# start_time is the last second of curr_date
start_time = time.mktime(next_date.timetuple()) - 1
history = [(i["url"], i["title"],
datetime.datetime.fromtimestamp(i["time"]),
QUrl(i["url"]).host())
for i in history_data(start_time)]
return 'text/html', jinja.render(
'history_nojs.html',
title='History',
history=history,
curr_date=curr_date,
next_date=next_date,
prev_date=prev_date,
today=datetime.date.today(),
)
def qute_pdfjs(url: QUrl) -> _HandlerRet:
"""Handler for qute://pdfjs.
Return the pdf.js viewer or redirect to original URL if the file does not
exist.
"""
if url.path() == '/file':
filename = QUrlQuery(url).queryItemValue('filename')
if not filename:
raise UrlInvalidError("Missing filename")
if '/' in filename or os.sep in filename:
raise RequestDeniedError("Path separator in filename.")
path = _pdf_path(filename)
with open(path, 'rb') as f:
data = f.read()
mimetype = utils.guess_mimetype(filename, fallback=True)
return mimetype, data
if url.path() == '/web/viewer.html':
query = QUrlQuery(url)
filename = query.queryItemValue("filename")
if not filename:
raise UrlInvalidError("Missing filename")
path = _pdf_path(filename)
if not os.path.isfile(path):
source = query.queryItemValue('source')
if not source: # This may happen with old URLs stored in history
raise UrlInvalidError("Missing source")
raise Redirect(QUrl(source))
data = pdfjs.generate_pdfjs_page(filename, url)
return 'text/html', data
try:
data = pdfjs.get_pdfjs_res(url.path())
except pdfjs.PDFJSNotFound as e:
# Logging as the error might get lost otherwise since we're not showing
# the error page if a single asset is missing. This way we don't lose
# information, as the failed pdfjs requests are still in the log.
log.misc.warning(
"pdfjs resource requested but not found: {}".format(e.path))
raise NotFoundError("Can't find pdfjs resource '{}'".format(e.path))
else:
mimetype = utils.guess_mimetype(url.fileName(), fallback=True)
return mimetype, data
def getIpAddressReport(self, ipAddress):
"""
Public method to retrieve a report for an IP address.
@param ipAddress valid IPv4 address in dotted quad notation
@type str
"""
self.__lastIP = ipAddress
queryItems = [
("apikey", Preferences.getHelp("VirusTotalServiceKey")),
("ip", ipAddress),
]
url = QUrl(self.GetIpAddressReportUrl)
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
query = QUrlQuery()
query.setQueryItems(queryItems)
url.setQuery(query)
else:
url.setQueryItems(queryItems)
request = QNetworkRequest(url)
import Helpviewer.HelpWindow
nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager()
reply = nam.get(request)
reply.finished.connect(self.__getIpAddressReportFinished)
self.__replies.append(reply)
def pydoc(self, job, url):
from pygments.formatters import HtmlFormatter
from pygments.lexers.python import Python3Lexer
from pygments import highlight
modname = url.path().lstrip("/")
query = QUrlQuery(url)
extras = {}
if query.hasQueryItem("hl_lines"):
start, end = query.queryItemValue("hl_lines").split("-")
extras["hl_lines"] = list(range(int(start), int(end) + 1))
mod = importlib.import_module(modname)
filepath = inspect.getsourcefile(mod)
formatter = HtmlFormatter(title="Module %s" % modname,
full=True,
lineanchors="line",
**extras)
with open(filepath) as f:
code = highlight(f.read(), Python3Lexer(), formatter)
buffer = QBuffer(self)
buffer.setData(code.encode("utf-8"))
job.reply(b"text/html", buffer)
def check_for_updates(self):
if self.checkBox_UpdateCheck.isChecked():
print("check for updates")
update_key = self.updateKey.displayText()
if len(update_key) == 50:
data = QUrlQuery()
data.addQueryItem("update_key", update_key)
data.addQueryItem("product", "OnAirScreen")
data.addQueryItem("current_version", versionString)
data.addQueryItem("distribution", distributionString)
data.addQueryItem("mac", self.get_mac())
data.addQueryItem(
"include_beta",
f'{self.checkBox_IncludeBetaVersions.isChecked()}')
req = QtNetwork.QNetworkRequest(QUrl(update_url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.nam_update_check = QtNetwork.QNetworkAccessManager()
self.nam_update_check.finished.connect(
self.handle_update_check_response)
self.nam_update_check.post(
req,
data.toString(QUrl.FullyEncoded).encode("UTF-8"))
else:
print("error, update key in wrong format")
self.error_dialog = QErrorMessage()
self.error_dialog.setWindowTitle("Update Check Error")
self.error_dialog.showMessage(
'Update key is in the wrong format!', 'UpdateKeyError')
def _generate_pdfjs_script(filename):
"""Generate the script that shows the pdf with pdf.js.
Args:
filename: The name of the file to open.
"""
url = QUrl('qute://pdfjs/file')
url_query = QUrlQuery()
url_query.addQueryItem('filename', filename)
url.setQuery(url_query)
js_url = javascript.to_js(
url.toString(QUrl.FullyEncoded)) # type: ignore[arg-type]
return jinja.js_environment.from_string("""
document.addEventListener("DOMContentLoaded", function() {
if (typeof window.PDFJS !== 'undefined') {
// v1.x
window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info;
} else {
// v2.x
const options = window.PDFViewerApplicationOptions;
options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS);
}
const viewer = window.PDFView || window.PDFViewerApplication;
viewer.open({{ url }});
});
""").render(url=js_url)
def url(self):
"""
Public method to generate the URL for this subscription.
@return AdBlock URL for the subscription (QUrl)
"""
url = QUrl()
url.setScheme("abp")
url.setPath("subscribe")
queryItems = []
queryItems.append(("location", bytes(self.__location).decode()))
queryItems.append(("title", self.__title))
if self.__requiresLocation and self.__requiresTitle:
queryItems.append(("requiresLocation", self.__requiresLocation))
queryItems.append(("requiresTitle", self.__requiresTitle))
if not self.__enabled:
queryItems.append(("enabled", "false"))
if self.__lastUpdate.isValid():
queryItems.append(
("lastUpdate", self.__lastUpdate.toString(Qt.ISODate)))
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
query = QUrlQuery()
query.setQueryItems(queryItems)
url.setQuery(query)
else:
url.setQueryItems(queryItems)
return url
def url_with_param(url, params) -> str:
url = QUrl(url)
q = QUrlQuery(url)
for key, value in params.items():
q.addQueryItem(key, value)
url.setQuery(q)
return url.url()
def suggestionsUrl(self, searchTerm):
"""
Public method to get a URL ready for suggestions.
@param searchTerm term to search for (string)
@return URL (QUrl)
"""
if not self._suggestionsUrlTemplate:
return QUrl()
ret = QUrl.fromEncoded(
QByteArray(
self.parseTemplate(
searchTerm, self._suggestionsUrlTemplate).encode("utf-8")))
if self.__searchMethod != "post":
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
urlQuery = QUrlQuery(ret)
for parameter in self._suggestionsParameters:
urlQuery.addQueryItem(
parameter[0],
self.parseTemplate(searchTerm, parameter[1]))
ret.setQuery(urlQuery)
else:
for parameter in self._suggestionsParameters:
ret.addQueryItem(
parameter[0],
self.parseTemplate(searchTerm, parameter[1]))
return ret
def addSubscriptionFromUrl(self, url):
"""
Public method to ad an AdBlock subscription given the abp URL.
@param url URL to subscribe an AdBlock subscription
@type QUrl
@return flag indicating success
@rtype bool
"""
if url.path() != "subscribe":
return False
title = QUrl.fromPercentEncoding(
QByteArray(QUrlQuery(url).queryItemValue("title").encode()))
if not title:
return False
res = E5MessageBox.yesNo(
None, self.tr("Subscribe?"),
self.tr("""<p>Subscribe to this AdBlock subscription?</p>"""
"""<p>{0}</p>""").format(title))
if res:
from .AdBlockSubscription import AdBlockSubscription
from WebBrowser.WebBrowserWindow import WebBrowserWindow
dlg = WebBrowserWindow.adBlockManager().showDialog()
subscription = AdBlockSubscription(
url, False, WebBrowserWindow.adBlockManager())
WebBrowserWindow.adBlockManager().addSubscription(subscription)
dlg.addSubscription(subscription, False)
dlg.setFocus()
dlg.raise_()
return res
def init(main_widget, my_id='', oppenent_id=''):
WebChatFrame.q_widget = QtWidgets.QWidget()
WebChatFrame.q_widget.show()
WebChatFrame.q_widget.setFixedSize(300, 600)
WebChatFrame.q_widget.move(
main_widget.mapToGlobal(QPoint(main_widget.width() + 1, -23)))
horizontalLayout = QtWidgets.QHBoxLayout(WebChatFrame.q_widget)
horizontalLayout.setContentsMargins(0, 0, 0, 0)
view = QtWebEngineWidgets.QWebEngineView(WebChatFrame.q_widget)
horizontalLayout.addWidget(view)
view.settings().setAttribute(
QtWebEngineWidgets.QWebEngineSettings.PluginsEnabled, True)
view.settings().setAttribute(
QtWebEngineWidgets.QWebEngineSettings.JavascriptEnabled, True)
url = QUrl(WebChatFrame.url + '/chat')
urldata = QUrlQuery()
urldata.addQueryItem('my_id', my_id)
urldata.addQueryItem('oppenent_id', oppenent_id)
url.setQuery(urldata)
view.setUrl(url)
view.show()
def __dataRequest(self, page, client_id, client_secret, date_from, date_to, polygon):
if not self.isAuthorized():
self.authRequest(client_id, client_secret, page, date_from, date_to, polygon)
return
print("page=", page)
# print("accessTokenExpires=", self.__accessTokenExpires.toString(Qt.ISODate))
date_format = "yyyy-MM-ddThh:mm"
url = QUrl(THERMAL_ANOMALY_URL)
url_query = QUrlQuery()
if polygon is not None:
url_query.addQueryItem("polygon", polygon)
if date_from is not None:
url_query.addQueryItem("shooting", "ge" + date_from.toString(date_format))
if date_to is not None:
url_query.addQueryItem("shooting", "le" + date_to.toString(date_format))
# _take=1000&_skip=0&_lastUpdated=ge2020-04-08T00%3A00%3A00
url_query.addQueryItem("_take", str(TAKE))
url_query.addQueryItem("_skip", str(page * TAKE).zfill(1))
# url.setQuery(url_query)
print(url_query.queryItems())
request = QtNetwork.QNetworkRequest()
request.setRawHeader(b'Authorization', ('Bearer ' + self.__accessToken).encode())
request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json".encode())
request.setUrl(url)
# print("request: ", url)
self.dataReply = self.__manager.post(request, url_query.toString(QUrl.FullyEncoded).encode())
self.dataReply.finished.connect(lambda dr=self.dataReply: self.__data_request_finished(dr, client_id, client_secret, date_from, date_to, polygon))
def _generate_pdfjs_script(filename):
"""Generate the script that shows the pdf with pdf.js.
Args:
filename: The name of the file to open.
"""
url = QUrl('qute://pdfjs/file')
url_query = QUrlQuery()
url_query.addQueryItem('filename', filename)
url.setQuery(url_query)
return jinja.js_environment.from_string("""
document.addEventListener("DOMContentLoaded", function() {
{% if disable_create_object_url %}
PDFJS.disableCreateObjectURL = true;
{% endif %}
PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;
const viewer = window.PDFView || window.PDFViewerApplication;
viewer.open("{{ url }}");
});
""").render(
url=javascript.string_escape(url.toString(QUrl.FullyEncoded)),
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70420
disable_create_object_url=(
not qtutils.version_check('5.12')
and not qtutils.version_check('5.7.1', exact=True, compiled=False)
and objects.backend == usertypes.Backend.QtWebEngine))
def getDomainReport(self, domain):
"""
Public method to retrieve a report for a domain.
@param domain domain name
@type str
"""
self.__lastDomain = domain
queryItems = [
("apikey", Preferences.getHelp("VirusTotalServiceKey")),
("domain", domain),
]
url = QUrl(self.GetDomainReportUrl)
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
query = QUrlQuery()
query.setQueryItems(queryItems)
url.setQuery(query)
else:
url.setQueryItems(queryItems)
request = QNetworkRequest(url)
import Helpviewer.HelpWindow
nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager()
reply = nam.get(request)
reply.finished.connect(self.__getDomainReportFinished)
self.__replies.append(reply)
def exchange_authorization_code(self, authorization_code, scopes,
callback):
log.debug(
"OAuth: exchanging authorization_code %s for an access_token",
authorization_code)
host, port = config.setting['server_host'], config.setting[
'server_port']
path = "/oauth2/token"
url = QUrl()
url_query = QUrlQuery()
url_query.addQueryItem("grant_type", "authorization_code")
url_query.addQueryItem("code", authorization_code)
url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID)
url_query.addQueryItem("client_secret",
MUSICBRAINZ_OAUTH_CLIENT_SECRET)
url_query.addQueryItem("redirect_uri", "urn:ietf:wg:oauth:2.0:oob")
url.setQuery(url_query.query(QUrl.FullyEncoded))
data = string_(url.query())
self.xmlws.post(host,
port,
path,
data,
partial(self.on_exchange_authorization_code_finished,
scopes, callback),
xml=False,
mblogin=True,
priority=True,
important=True)
def getHttp(self, uri, params):
QgsApplication.setOverrideCursor(Qt.WaitCursor)
try:
rq = QUrl(uri)
q = QUrlQuery()
for (k, v) in params.items():
q.addQueryItem(k, v)
rq.setQuery(q)
req = QNetworkRequest(rq)
try:
reply = self.nominatim_networkAccessManager.blockingGet(req)
resource = reply.content().data().decode('utf8')
r = json.loads(resource)
if (isinstance(r, list)):
self.populateTable(r)
else:
self.populateTable([r])
except:
self.tableResult.clearContents()
finally:
QgsApplication.restoreOverrideCursor()
def refresh_access_token(self, callback):
refresh_token = config.persist["oauth_refresh_token"]
log.debug("OAuth: refreshing access_token with a refresh_token %s",
refresh_token)
host, port = config.setting['server_host'], config.setting[
'server_port']
path = "/oauth2/token"
url = QUrl()
url_query = QUrlQuery()
url_query.addQueryItem("grant_type", "refresh_token")
url_query.addQueryItem("refresh_token", refresh_token)
url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID)
url_query.addQueryItem("client_secret",
MUSICBRAINZ_OAUTH_CLIENT_SECRET)
url.setQuery(url_query.query(QUrl.FullyEncoded))
data = string_(url.query())
self.xmlws.post(host,
port,
path,
data,
partial(self.on_refresh_access_token_finished,
callback),
xml=False,
mblogin=True,
priority=True,
important=True)
def auto_suggest(self):
text = self._editor.text()
if self.catch_coordinates(text):
pass
elif text:
is_offline = False if QgsSettings().value("/kadas/isOffline") == "false" else True
LOG.debug("is_offline %s" % is_offline)
if is_offline:
url = QgsSettings().value(
"search/locationofflinesearchurl",
"http://localhost:5000/SearchServerCh",
)
else:
url = QgsSettings().value(
"search/locationsearchurl",
"https://api3.geo.admin.ch/rest/services/api/SearchServer",
)
url = QUrl(url)
query = QUrlQuery()
query.addQueryItem("sr", "2056")
query.addQueryItem("searchText", text)
query.addQueryItem("lang", "en")
query.addQueryItem("type", "locations")
query.addQueryItem("limit", "10")
url.setQuery(query)
LOG.debug(url)
self._network_manager.get(QNetworkRequest(url))
def _render_header(title, mode, phrase, filters):
r = []
r.append(ADV_HEADER)
r.append('<h1>{0}</h1>'.format(title))
r.append('<ul class="nav">\n')
modes = [(name, spec) for (name, spec) in MODE_DICT.items()]
modes.sort(key=itemgetter(0))
for (name, spec) in modes:
href = QUrl('search:///')
urlquery = QUrlQuery()
if phrase:
urlquery.addQueryItem('phrase', phrase)
if filters:
urlquery.addQueryItem('filters', filters)
urlquery.addQueryItem('mode', name)
href.setQuery(urlquery)
if name != mode:
r.append('<li><a href="{href}">{title}</a></li>\n'.format(
href=href.toEncoded(), title=spec['title']))
else:
r.append('<li><span class="sel">{title}<span></li>\n'.format(
href=href.toEncoded(), title=spec['title']))
r.append('</ul>\n')
return ''.join(r)
def _render_header(title, mode, phrase, filters):
r = []
r.append(ADV_HEADER)
r.append("<h1>{0}</h1>".format(title))
r.append('<ul class="nav">\n')
modes = [(name, spec) for (name, spec) in MODE_DICT.items()]
modes.sort(key=itemgetter(0))
for (name, spec) in modes:
q = QUrlQuery()
if phrase:
q.addQueryItem("phrase", phrase)
if filters:
q.addQueryItem("filters", filters)
q.addQueryItem("mode", name)
href = QUrl("search:///?" + q.toString())
if name != mode:
r.append(
'<li><a href="{href}">{title}</a></li>\n'.format(
href=href.toString(), title=spec["title"]
)
)
else:
r.append(
'<li><span class="sel">{title}<span></li>\n'.format(title=spec["title"])
)
r.append("</ul>\n")
return "".join(r)
def getRemoteTiles(self):
query = QUrlQuery()
url = QUrl(f"{self.url}/search")
query.addQueryItem("q", self.search_str)
query.addQueryItem("f", "pjson")
url.setQuery(query.query())
response = QgsNetworkAccessManager.blockingGet(
QNetworkRequest(QUrl(url)))
if response.error() != QNetworkReply.NoError:
raise Exception(response.errorString())
responsejson = json.loads(response.content().data())
LOG.debug("response from data repository: %s" % responsejson)
tiles = []
for result in responsejson["results"]:
itemid = result["id"]
timestamp = self.dataTimestamp(itemid)
if timestamp is None:
status = self.NOT_INSTALLED
elif timestamp < result["modified"]:
status = self.UPDATABLE
else:
status = self.UP_TO_DATE
tile = dict(result)
tile["status"] = status
tiles.append(tile)
return tiles
def search_and_render(url, fulltext_hp, fulltext_de):
query = dict((k, v) for (k, v) in QUrlQuery(url).queryItems())
mode = query.get("mode", None)
phrase = query.get("phrase", None)
filters = query.get("filters", None)
r = []
if mode in MODE_DICT:
spec = MODE_DICT[mode]
searcher = fulltext_hp if (spec["searcher"] == "hp") else fulltext_de
collector = searcher.make_collector(spec["limit"])
res = searcher.search(
collector,
query_str1=phrase,
query_str2=filters,
itemtypes=spec["itemtypes"],
highlight=spec["highlight"],
)
r.append(_render_header(spec["title"], mode, phrase, filters))
r.append(spec["renderer"](res, mode))
r.append(_render_footer())
else:
r.append(_render_header("Advanced Search", mode, phrase, filters))
r.append(_render_footer())
return "".join(r)
def exchange_authorization_code(self, authorization_code, scopes,
callback):
log.debug(
"OAuth: exchanging authorization_code %s for an access_token",
authorization_code)
path = "/oauth2/token"
url = QUrl()
url_query = QUrlQuery()
url_query.addQueryItem("grant_type", "authorization_code")
url_query.addQueryItem("code", authorization_code)
url_query.addQueryItem("client_id", MUSICBRAINZ_OAUTH_CLIENT_ID)
url_query.addQueryItem("client_secret",
MUSICBRAINZ_OAUTH_CLIENT_SECRET)
url_query.addQueryItem("redirect_uri", "urn:ietf:wg:oauth:2.0:oob")
url.setQuery(url_query.query(QUrl.FullyEncoded))
data = url.query()
self.webservice.post(
self.host,
self.port,
path,
data,
partial(self.on_exchange_authorization_code_finished, scopes,
callback),
mblogin=True,
priority=True,
important=True,
request_mimetype="application/x-www-form-urlencoded")
def test_file_pathsep(self, sep):
url = QUrl('qute://pdfjs/file')
query = QUrlQuery()
query.addQueryItem('filename', 'foo{}bar'.format(sep))
url.setQuery(query)
with pytest.raises(qutescheme.RequestDeniedError):
qutescheme.data_for_url(url)
def _handle_reply(self, reply, request, handler, xml, refresh):
error = int(reply.error())
if error:
log.error("Network request error for %s: %s (QT code %d, HTTP code %s)",
reply.request().url().toString(QUrl.RemoveUserInfo),
reply.errorString(),
error,
repr(reply.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute))
)
if handler is not None:
handler(reply.readAll(), reply, error)
else:
redirect = reply.attribute(QtNetwork.QNetworkRequest.RedirectionTargetAttribute)
fromCache = reply.attribute(QtNetwork.QNetworkRequest.SourceIsFromCacheAttribute)
cached = ' (CACHED)' if fromCache else ''
log.debug("Received reply for %s: HTTP %d (%s) %s",
reply.request().url().toString(QUrl.RemoveUserInfo),
reply.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute),
reply.attribute(QtNetwork.QNetworkRequest.HttpReasonPhraseAttribute),
cached
)
if handler is not None:
# Redirect if found and not infinite
if redirect:
url = request.url()
# merge with base url (to cover the possibility of the URL being relative)
redirect = url.resolved(redirect)
if not XmlWebService.urls_equivalent(redirect, reply.request().url()):
log.debug("Redirect to %s requested", redirect.toString(QUrl.RemoveUserInfo))
redirect_host = string_(redirect.host())
redirect_port = self.url_port(redirect)
redirect_query = dict(QUrlQuery(redirect).queryItems(QUrl.FullyEncoded))
redirect_path = redirect.path()
original_host = string_(url.host())
original_port = self.url_port(url)
if ((original_host, original_port) in REQUEST_DELAY
and (redirect_host, redirect_port) not in REQUEST_DELAY):
log.debug("Setting rate limit for %s:%i to %i" %
(redirect_host, redirect_port,
REQUEST_DELAY[(original_host, original_port)]))
REQUEST_DELAY[(redirect_host, redirect_port)] =\
REQUEST_DELAY[(original_host, original_port)]
self.get(redirect_host,
redirect_port,
redirect_path,
handler, xml, priority=True, important=True, refresh=refresh, queryargs=redirect_query,
cacheloadcontrol=request.attribute(QtNetwork.QNetworkRequest.CacheLoadControlAttribute))
else:
log.error("Redirect loop: %s",
reply.request().url().toString(QUrl.RemoveUserInfo)
)
handler(reply.readAll(), reply, error)
elif xml:
document = _read_xml(QXmlStreamReader(reply))
handler(document, reply, error)
else:
handler(reply.readAll(), reply, error)
def encode_uri(ds_uri, schema_name, project_name=None):
u = QUrl()
urlQuery = QUrlQuery()
u.setScheme("postgresql")
u.setHost(ds_uri.host())
if ds_uri.port() != '':
u.setPort(int(ds_uri.port()))
if ds_uri.username() != '':
u.setUserName(ds_uri.username())
if ds_uri.password() != '':
u.setPassword(ds_uri.password())
if ds_uri.service() != '':
urlQuery.addQueryItem("service", ds_uri.service())
if ds_uri.authConfigId() != '':
urlQuery.addQueryItem("authcfg", ds_uri.authConfigId())
if ds_uri.sslMode() != QgsDataSourceUri.SslPrefer:
urlQuery.addQueryItem("sslmode", QgsDataSourceUri.encodeSslMode(ds_uri.sslMode()))
urlQuery.addQueryItem("dbname", ds_uri.database())
urlQuery.addQueryItem("schema", schema_name)
if project_name:
urlQuery.addQueryItem("project", project_name)
u.setQuery(urlQuery)
return str(u.toEncoded(), 'utf-8')
def _handle_redirect(self, reply, request, redirect):
url = request.url()
error = int(reply.error())
# merge with base url (to cover the possibility of the URL being relative)
redirect = url.resolved(redirect)
if not WebService.urls_equivalent(redirect, reply.request().url()):
log.debug("Redirect to %s requested", redirect.toString(QUrl.RemoveUserInfo))
redirect_host = redirect.host()
redirect_port = self.url_port(redirect)
redirect_query = dict(QUrlQuery(redirect).queryItems(QUrl.FullyEncoded))
redirect_path = redirect.path()
original_host = url.host()
original_port = self.url_port(url)
original_host_key = (original_host, original_port)
redirect_host_key = (redirect_host, redirect_port)
ratecontrol.copy_minimal_delay(original_host_key, redirect_host_key)
self.get(redirect_host,
redirect_port,
redirect_path,
request.handler, request.parse_response_type, priority=True, important=True,
refresh=request.refresh, queryargs=redirect_query,
cacheloadcontrol=request.attribute(QNetworkRequest.CacheLoadControlAttribute))
else:
log.error("Redirect loop: %s",
reply.request().url().toString(QUrl.RemoveUserInfo)
)
request.handler(reply.readAll(), reply, error)
def handle_form_submitted(self, qurl, elements=dict()):
# print("\n\ngot url: ", qurl)
qqurl = QUrlQuery(qurl)
for key, value in qqurl.queryItems():
elements[key] = value
self.render(qurl.path(), elements)
def get_main_url(filename):
"""Get the URL to be opened to view a local PDF."""
url = QUrl('qute://pdfjs/web/viewer.html')
query = QUrlQuery()
query.addQueryItem('filename', filename) # read from our JS
query.addQueryItem('file', '') # to avoid pdfjs opening the default PDF
url.setQuery(query)
return url
def test3(self):
url = QUrl("http://localhost:18080/user")
query = QUrlQuery()
query.addQueryItem("username", "yqfcpy");
query.addQueryItem("password", "111111");
url.setQuery(query.query())
print(query.query())
print(url)
