def open(self, address, method='get', headers={}, auth=None, body=None,
default_popup_response=None):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tuple of HTTP auth (username, password).
:param body: An optional string containing a payload.
:param default_popup_response: the default response for any confirm/
alert/prompt popup from the Javascript (replaces the need for the with
blocks)
:return: Page resource, All loaded resources.
"""
body = body or QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Error("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
if default_popup_response is not None:
Ghost._prompt_expected = (default_popup_response, None)
Ghost._confirm_expected = (default_popup_response, None)
return self.wait_for_page_loaded()
def fetch_banner(self, url, index, cache=True):
"""Creates a request to load a banner from the given URL.
A request is defined by its URL and carried out asynchronously.
The result is stored on disk if caching is enabled. When a request
has been completed, :py:meth:`.finished_request` will be invoked.
:param url: The location of the banner to load.
:type url: string
:param index: The index referring to a :class:`.DecoratedNode`
to fetch a banner for (origin of the request). Used to inform
the node's model when the request was finished.
:type index: :class:`~.PySide.QtCore.QModelIndex`
:param cache: Determines if the loaded banner should be cached on disk.
:type cache: bool
"""
request = QNetworkRequest(QUrl(url))
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.PreferCache)
request.setAttribute(QNetworkRequest.CacheSaveControlAttribute, cache)
reply = access_manager.get(request)
self._ready_signal[url] = index
from_cache = bool(reply.attribute(QNetworkRequest.SourceIsFromCacheAttribute))
logger.debug("Loading '{}' (Cached: {})".format(url, from_cache))
def open(self, address, method='get', headers={}, auth=None, body=None,
default_popup_response=None):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tuple of HTTP auth (username, password).
:param body: An optional string containing a payload.
:param default_popup_response: the default response for any confirm/
alert/prompt popup from the Javascript (replaces the need for the with
blocks)
:return: Page resource, All loaded resources.
"""
body = body or QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Error("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
if default_popup_response is not None:
Ghost._prompt_expected = (default_popup_response, None)
Ghost._confirm_expected = (default_popup_response, None)
return self.wait_for_page_loaded()
def createRequest(self, operation, request, device=None):
if self.headers:
request = QNetworkRequest(request)
if operation != QNetworkAccessManager.PostOperation and operation != QNetworkAccessManager.PutOperation :
request.setHeader(QNetworkRequest.ContentTypeHeader, None)
for item in self.headers.iteritems():
request.setRawHeader(*item)
return QNetworkAccessManager.createRequest(self,operation, request, device)
def testRequestCtor(self):
request = QNetworkRequest(QUrl('http://example.com/movie.mov'))
request.setAttribute(QNetworkRequest.User, 1234)
media = QMediaContent(request)
self.assertEqual(media.canonicalUrl(), QUrl('http://example.com/movie.mov'))
self.assertEqual(media.canonicalResource().request(), request)
self.assertEqual(media.canonicalResource().url(), QUrl('http://example.com/movie.mov'))
def testRequestCtor(self):
request = QNetworkRequest(QUrl('http://example.com/movie.mov'))
request.setAttribute(QNetworkRequest.User, 1234)
media = QMediaContent(request)
self.assertEqual(media.canonicalUrl(),
QUrl('http://example.com/movie.mov'))
self.assertEqual(media.canonicalResource().request(), request)
self.assertEqual(media.canonicalResource().url(),
QUrl('http://example.com/movie.mov'))
def _prepare_request(self, url, headers):
# create an empty request
request = QNetworkRequest()
# assign a url to it
request.setUrl(QUrl(url))
# add some custom headers to the request
for (header_name, header_value) in headers.items():
request.setRawHeader(header_name, QByteArray(header_value))
return request
def test_connection(self):
self.message.setText(
'<span style="font-size: 10px; color: #000000;">' +
'Verbindung wird getestet.' + '</span>')
self.nam.finished.connect(self.test_reply)
self.nam.sslErrors.connect(self.ssl_errors)
ssl_config = QSslConfiguration().defaultConfiguration()
ssl_config.setCiphers(QSslSocket().supportedCiphers())
if self.certificate:
certificate = QSslCertificate(encoded=self.certificate,
format=QSsl.Pem)
ssl_config.setCaCertificates([certificate])
else:
ssl_config.setCaCertificates([])
url = QUrl(self.url_edit.text())
url.setPath("/".join(
filter(bool, (url.path() + "/ajax/read.php").split("/"))))
request = QNetworkRequest(url)
request.setSslConfiguration(ssl_config)
request.setRawHeader(
"Authorization", "Basic ".encode('utf-8') + b64encode(
(self.username_edit.text() + ":" +
self.password_edit.text()).encode('utf-8')))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.replies.add(self.nam.post(request, QByteArray()))
def open(self, address, method='get', headers={}):
body = QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Exception("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
for header in headers:
request.setRawHeader(header, headers[header])
self._view.page().currentFrame().load(request, method, body)
self._wait_for_page()
def open(self, address, method='get', headers={}, auth=None, body=None,
default_popup_response=None, wait=True):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tuple of HTTP auth (username, password).
:param body: An optional string containing a payload.
:param default_popup_response: the default response for any confirm/
alert/prompt popup from the Javascript (replaces the need for the with
blocks)
:param wait: If set to True (which is the default), this
method call waits for the page load to complete before
returning. Otherwise, it just starts the page load task and
it is the caller's responsibilty to wait for the load to
finish by other means (e.g. by calling wait_for_page_loaded()).
:return: Page resource, and all loaded resources, unless wait
is False, in which case it returns None.
"""
body = body or QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Error("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
if default_popup_response is not None:
Ghost._prompt_expected = (default_popup_response, None)
Ghost._confirm_expected = (default_popup_response, None)
if wait:
return self.wait_for_page_loaded()
def createRequest(self, op, req, outgoingData=None): # override
url = req.url()
#print url
#if url.scheme() == 'https' and url.host() in ('www.dmm.com', 'dmm.com'):
# path = url.path()
# if path.startswith('/js/') or path.startswith('/css/'):
# url.setScheme('http') # downgrade to http
# req.setUrl(url)
# dprint("downgrade https to http:", url)
#print url
newurl = _WbNetworkAccessManager.getBlockedUrl(url)
if newurl:
req = QNetworkRequest(newurl)
else:
newurl = proxy.toproxyurl(url)
if newurl and newurl != url:
req = QNetworkRequest(req) # since request tis constent
req.setUrl(newurl)
_WbNetworkAccessManager.setRequestHeaders(req)
reply = super(WbNetworkAccessManager,
self).createRequest(op, req, outgoingData)
#if url.host().lower().endswith('dmm.co.jp'):
reply.setUrl(url) # restore the old url
reply.setProperty(REQ_PROXY_URL, url)
#print newurl
return reply
#else:
# print url
_WbNetworkAccessManager.setRequestHeaders(req)
return super(WbNetworkAccessManager,
self).createRequest(op, req, outgoingData)
def get(self, url, local_path):
print "url", url
print "local_path", local_path
self.url = url
self.local_path = local_path
self.mb = DownloadMessageBox(self.parent())
self.mb.buttonClicked.connect(self.handleCancel)
self.mb.rejected.connect(self.handleReject)
mgr = QNetworkAccessManager(self)
mgr.finished.connect(self.handleFinished)
self.reply = mgr.get(QNetworkRequest(QUrl(url)))
self.reply.downloadProgress.connect(self.mb.updateProgress)
self.mb.exec_()
def open(self, address, method="GET", **kwargs):
"""
Open a URL in the current frame.
:param address: the url to open
:param method: the HTTP method to use. Defaults to 'GET'.
"""
body = QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise SpecterError("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
# If we have headers...
if 'headers' in kwargs:
for header, val in kwargs['headers'].items():
request.setRawHeader(header, val)
self._frame.load(request, method, body)
def get(self, url, path):
"""
@param url unicode or QUrl
@param unicode path
@return bool whether succeeded
"""
dprint('enter:', url)
d = self.__d
d.stop()
if d.openFile(path):
if not isinstance(url, QUrl):
url = QUrl(url)
d.request = QNetworkRequest(url)
ok = d.start()
else:
ok = False
dprint('leave: ret = %s' % ok)
return ok
def test_connection(self):
self.message.setText('<span style="font-size: 10px; color: #000000;">' +
'Verbindung wird getestet.' +
'</span>')
self.nam.finished.connect(self.test_reply)
self.nam.sslErrors.connect(self.ssl_errors)
ssl_config = QSslConfiguration().defaultConfiguration()
ssl_config.setCiphers(QSslSocket().supportedCiphers())
if self.certificate:
certificate = QSslCertificate(encoded=self.certificate, format=QSsl.Pem)
ssl_config.setCaCertificates([certificate])
else:
ssl_config.setCaCertificates([])
url = QUrl(self.url_edit.text())
url.setPath("/".join(filter(bool, (url.path() + "/ajax/read.php").split("/"))))
request = QNetworkRequest(url)
request.setSslConfiguration(ssl_config)
request.setRawHeader("Authorization",
"Basic ".encode('utf-8') +
b64encode((self.username_edit.text() + ":" + self.password_edit.text()).encode('utf-8')))
request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
self.replies.add(self.nam.post(request, QByteArray()))
def do_download(self, dl_url):
url = QUrl(dl_url)
req = QNetworkRequest(url)
reply = self.manager.get(req)
self.current_downloads[reply] = dl_url
def _make_request(self, url):
request = QNetworkRequest()
request.setUrl(QUrl(url))
return request
