Beispiel #1
0
 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
Beispiel #2
0
 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")
Beispiel #3
0
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)
Beispiel #4
0
 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))
Beispiel #5
0
 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 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 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()
Beispiel #8
0
 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 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
Beispiel #10
0
 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
Beispiel #11
0
 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()
Beispiel #12
0
    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))
Beispiel #14
0
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 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')
Beispiel #16
0
 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)
Beispiel #17
0
 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)
Beispiel #18
0
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
Beispiel #19
0
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 addEngineFromForm(self, res, view):
        """
        Public method to add a new search engine from a form.
        
        @param res result of the JavaScript run on by
            WebBrowserView.__addSearchEngine()
        @type dict or None
        @param view reference to the web browser view
        @type WebBrowserView
        """
        if not res:
            return

        method = res["method"]
        actionUrl = QUrl(res["action"])
        inputName = res["inputName"]

        if method != "get":
            E5MessageBox.warning(
                self, self.tr("Method not supported"),
                self.tr("""{0} method is not supported.""").format(
                    method.upper()))
            return

        if actionUrl.isRelative():
            actionUrl = view.url().resolved(actionUrl)

        searchUrlQuery = QUrlQuery(actionUrl)
        searchUrlQuery.addQueryItem(inputName, "{searchTerms}")

        inputFields = res["inputs"]
        for inputField in inputFields:
            name = inputField[0]
            value = inputField[1]

            if not name or name == inputName or not value:
                continue

            searchUrlQuery.addQueryItem(name, value)

        engineName, ok = QInputDialog.getText(
            view, self.tr("Engine name"),
            self.tr("Enter a name for the engine"), QLineEdit.Normal)
        if not ok:
            return

        actionUrl.setQuery(searchUrlQuery)

        from .OpenSearchEngine import OpenSearchEngine
        engine = OpenSearchEngine()
        engine.setName(engineName)
        engine.setDescription(engineName)
        engine.setSearchUrlTemplate(
            actionUrl.toDisplayString(QUrl.FullyDecoded))
        engine.setImage(view.icon().pixmap(16, 16).toImage())

        self.__addEngineByEngine(engine)
Beispiel #21
0
def email(subject, body):
    """Opens the e-mail composer with the given subject and body, with version information added to it."""
    subject = "[{0} {1}] {2}".format(appinfo.appname, appinfo.version, subject)
    body = "{0}\n\n{1}\n\n".format(debuginfo.version_info_string(' -- '), body)
    url = QUrl("mailto:" + appinfo.maintainer_email)
    query = QUrlQuery()
    query.addQueryItem("subject", subject)
    query.addQueryItem("body", body)
    url.setQuery(query)
    helpers.openUrl(url, "email")
Beispiel #22
0
 def load_account_page(self, account, tab=None, task=None):
     self.tab = tab
     self.task = task
     self.account = account
     url = QUrl(account.server.settings_url)
     url_query = QUrlQuery()
     for name, value in self.query_items:
         url_query.addQueryItem(name, value)
     url.setQuery(url_query)
     self.load(url)
Beispiel #23
0
def email(subject, body):
    """Opens the e-mail composer with the given subject and body, with version information added to it."""
    subject = "[{0} {1}] {2}".format(appinfo.appname, appinfo.version, subject)
    body = "{0}\n\n{1}\n\n".format(debuginfo.version_info_string(' -- '), body)
    url = QUrl("mailto:" + appinfo.maintainer_email)
    query = QUrlQuery()
    query.addQueryItem("subject", subject)
    query.addQueryItem("body", body)
    url.setQuery(query)
    helpers.openUrl(url, "email")
Beispiel #24
0
 def test6(self):
   a1 = 0.111111111111111111111111
   b1 = 0.111111111111111111111111
   print(a1 + b1)
   return None
   dic = {"username": "******", "password": 123456}
   path = QUrl("http://localhost:18080/user")
   query = QUrlQuery()
   if 1 != 2:
     for item in dic.items():
       query.addQueryItem(item[0], item[1])
     path.setQuery(query.query())
   log.info(path)
Beispiel #25
0
 def get(self, url: str, param: dict = None):
     # 创建一个请求
     path = QUrl(url)
     if param != None:
         query = QUrlQuery()
         for item in param.items():
             query.addQueryItem(item[0], str(item[1]))
         path.setQuery(query.query())
     req = QtNetwork.QNetworkRequest(path)
     self.nam = QtNetwork.QNetworkAccessManager()
     self.nam.finished.connect(self.handleResponse)
     # 使用get请求 如果有参数的话 写一个data 放到get里
     self.nam.get(req)
Beispiel #26
0
 def post(self, url: str, jsonBody: dict, param: dict = None):
     path = QUrl(url)
     sendData = QJsonDocument(jsonBody)
     if param != None:
         queryParams = QUrlQuery()
         for item in param.items():
             queryParams.addQueryItem(item[0], str(item[1]))
         path.setQuery(queryParams.query())
     req = QtNetwork.QNetworkRequest(path)
     # 设置头信息是json这里可以不写
     # req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/json")
     self.nam = QtNetwork.QNetworkAccessManager()
     self.nam.finished.connect(self.handleResponse)
     self.nam.post(req, sendData.toJson())
Beispiel #27
0
 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)
Beispiel #28
0
 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.webservice.post(host, port, path, data,
                     partial(self.on_exchange_authorization_code_finished, scopes, callback),
                     parse_response_type=None, mblogin=True, priority=True, important=True)
Beispiel #29
0
 def load_account_page(self, account, tab=None, task=None, reset_history=False, set_home=False):
     self.tab = tab
     self.task = task
     self.account = account
     url = QUrl(account.server.settings_url)
     url_query = QUrlQuery()
     for name, value in self.query_items:
         url_query.addQueryItem(name, value)
     url.setQuery(url_query)
     if set_home:
         self.homepage = url
     if reset_history:
         self.history().clear()
         self.page().mainFrame().evaluateJavaScript('window.location.replace("{}");'.format(url.toString()))  # this will replace the current url in the history
     else:
         self.load(url)
Beispiel #30
0
 def load_account_page(self, account, tab=None, task=None, reset_history=False, set_home=False):
     self.tab = tab
     self.task = task
     self.account = account
     url = QUrl(account.server.settings_url)
     url_query = QUrlQuery()
     for name, value in self.query_items:
         url_query.addQueryItem(name, value)
     url.setQuery(url_query)
     if set_home:
         self.homepage = url
     if reset_history:
         self.history().clear()
         self.page().mainFrame().evaluateJavaScript('window.location.replace("{}");'.format(url.toString()))  # this will replace the current url in the history
     else:
         self.load(url)
Beispiel #31
0
    def insertNoteLink(self):
        cursor = self.noteContentEdit.textCursor()

        filename = QFileDialog.getOpenFileName(self.noteContentEdit, 'Open File', ".", "(*.nbf)")[0]

        if filename:
            notebook = Notebook.from_file(filename)
            dialog = NoteSelectDialog(parent=self, notebook=notebook)
            result = dialog.exec_()

            if result == QDialog.Accepted:
                url: QUrl = QUrl.fromLocalFile(filename)
                url.setScheme("notesmanager")
                query = QUrlQuery()
                query.addQueryItem("uuid", str(dialog.selectedNote.uuid))
                url.setQuery(query)
                cursor.insertHtml(f"<a href=\"{url.toString()}\" >{dialog.caption}</a>")
Beispiel #32
0
    def loadMessages(self, skip=None, beforeId=None, afterId=None, limit=50):
        logger.debug("listMessages")
        url = QUrl(GITTER_API + "/rooms/{}/chatMessages".format(self.id))
        query = QUrlQuery()
        if skip:
            query.addQueryItem("skip", str(skip))
        if beforeId:
            query.addQueryItem("beforeId", str(beforeId))
        if afterId:
            query.addQueryItem("afterId", str(afterId))
        elif self._messages.last_id:
            query.addQueryItem("afterId", str(self._messages.last_id()))
        if limit:
            query.addQueryItem("limit", str(limit))

        url.setQuery(query)
        req = makeRequest(url, self._auth)
        reply = self._net.get(req)
        reply.finished.connect(lambda: self.readMessages(reply))
Beispiel #33
0
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
              {% if disable_create_object_url %}
              window.PDFJS.disableCreateObjectURL = true;
              {% endif %}
              window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info;
          } else {
              // v2.x
              const options = window.PDFViewerApplicationOptions;
              {% if disable_create_object_url %}
              options.set('disableCreateObjectURL', true);
              {% endif %}
              options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS);
          }

          const viewer = window.PDFView || window.PDFViewerApplication;
          viewer.open({{ url }});
        });
    """).render(
        url=js_url,
        # 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))
Beispiel #34
0
    def loadMessages(self, skip=None, beforeId=None, afterId=None, limit=50):
        logger.debug("listMessages")
        url = QUrl(
            GITTER_API + "/rooms/{}/chatMessages".format(self.id)
        )
        query = QUrlQuery()
        if skip:
            query.addQueryItem("skip", str(skip))
        if beforeId:
            query.addQueryItem("beforeId", str(beforeId))
        if afterId:
            query.addQueryItem("afterId", str(afterId))
        elif self._messages.last_id:
            query.addQueryItem("afterId", str(self._messages.last_id()))
        if limit:
            query.addQueryItem("limit", str(limit))

        url.setQuery(query)
        req = makeRequest(url, self._auth)
        reply = self._net.get(req)
        reply.finished.connect(lambda: self.readMessages(reply))
Beispiel #35
0
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)
Beispiel #36
0
    def block(self, info):
        """
        Public method to check, if a request should be blocked.
        
        @param info request info object
        @type QWebEngineUrlRequestInfo
        @return flag indicating to block the request
        @rtype bool
        """
        locker = QMutexLocker(self.__mutex)  # __IGNORE_WARNING__

        if not self.isEnabled():
            return False

        urlString = bytes(info.requestUrl().toEncoded()).decode().lower()
        urlDomain = info.requestUrl().host().lower()
        urlScheme = info.requestUrl().scheme().lower()

        if (not self.canRunOnScheme(urlScheme)
                or not self.__canBeBlocked(info.firstPartyUrl())):
            return False

        res = False
        blockedRule = self.__matcher.match(info, urlDomain, urlString)

        if blockedRule:
            res = True
            if (info.resourceType() ==
                    QWebEngineUrlRequestInfo.ResourceTypeMainFrame):
                url = QUrl("eric:adblock")
                query = QUrlQuery()
                query.addQueryItem("rule", blockedRule.filter())
                query.addQueryItem("subscription",
                                   blockedRule.subscription().title())
                url.setQuery(query)
                info.redirect(url)
            else:
                info.block(True)

        return res
Beispiel #37
0
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)
Beispiel #38
0
def exceptHook(type_, value, tback):
    stack = ''.join(traceback.format_exception(type_, value, tback))

    title = QApplication.translate("ExcpHook", "System error")
    text = QApplication.translate(
        "ExcpHook", "A system error occurred.\n"
        "Do you want to send an error message to the author?")
    msgBox = QMessageBox(QMessageBox.Information, title, text)
    msgBox.setDetailedText(stack)
    msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
    if msgBox.exec_() == QMessageBox.Yes:
        line = traceback.extract_tb(tback)[-1]
        subject = "[v%s] %s - %s:%d" % (version.Version, type_.__name__,
                                        line[0], line[1])

        errorMessage = []
        # errorMessage.append(QApplication.translate(
        #    "ExcpHook",
        #    "PLEASE ADD A COMMENT, IT WILL HELP IN SOLVING THE PROBLEM"))
        # errorMessage.append('')
        errorMessage.append("%s: %s" % (version.AppName, version.Version))
        errorMessage.append(
            "OS: %s %s (%s)" %
            (platform.system(), platform.release(), platform.version()))
        errorMessage.append(
            "Python: %s (%s)" %
            (platform.python_version(), platform.architecture()[0]))
        errorMessage.append("Qt: %s" % PYQT_VERSION_STR)
        try:
            errorMessage.append("Locale: %s" % Settings()['locale'])
        except:
            pass

        errorMessage.append('')
        errorMessage.append(stack)

        url = QUrl('http://opennumismat.idea.informer.com/proj/')
        query = QUrlQuery()
        query.addQueryItem('mod', 'add')
        query.addQueryItem('cat', '3')
        query.addQueryItem('idea', subject)
        query.addQueryItem('descr', '\n'.join(errorMessage))
        url.setQuery(query)

        executor = QDesktopServices()
        executor.openUrl(url)

    # Call the default handler
    sys.__excepthook__(type_, value, tback)
Beispiel #39
0
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 (typeof window.PDFJS !== 'undefined') {
              // v1.x
              {% if disable_create_object_url %}
              window.PDFJS.disableCreateObjectURL = true;
              {% endif %}
              window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info;
          } else {
              // v2.x
              const options = window.PDFViewerApplicationOptions;
              {% if disable_create_object_url %}
              options.set('disableCreateObjectURL', true);
              {% endif %}
              options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS);
          }

          const viewer = window.PDFView || window.PDFViewerApplication;
          viewer.open({{ url }});
        });
    """).render(
        url=javascript.to_js(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))
Beispiel #40
0
def exceptHook(type_, value, tback):
    stack = ''.join(traceback.format_exception(type_, value, tback))

    title = QApplication.translate("ExcpHook", "System error")
    text = QApplication.translate("ExcpHook",
                        "A system error occurred.\n"
                        "Do you want to send an error message to the author?")
    msgBox = QMessageBox(QMessageBox.Information, title, text)
    msgBox.setDetailedText(stack)
    msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
    if msgBox.exec_() == QMessageBox.Yes:
        line = traceback.extract_tb(tback)[-1]
        subject = "[v%s] %s - %s:%d" % (version.Version, type_.__name__,
                                        line[0], line[1])

        errorMessage = []
        # errorMessage.append(QApplication.translate(
        #    "ExcpHook",
        #    "PLEASE ADD A COMMENT, IT WILL HELP IN SOLVING THE PROBLEM"))
        # errorMessage.append('')
        errorMessage.append("%s: %s" % (version.AppName, version.Version))
        errorMessage.append("OS: %s %s (%s)" % (platform.system(),
                                                platform.release(),
                                                platform.version()))
        errorMessage.append("Python: %s (%s)" % (platform.python_version(),
                                                 platform.architecture()[0]))
        errorMessage.append("Qt: %s" % PYQT_VERSION_STR)
        try:
            errorMessage.append("Locale: %s" % Settings()['locale'])
        except:
            pass

        errorMessage.append('')
        errorMessage.append(stack)

        url = QUrl('http://opennumismat.idea.informer.com/proj/')
        query = QUrlQuery()
        query.addQueryItem('mod', 'add')
        query.addQueryItem('cat', '3')
        query.addQueryItem('idea', subject)
        query.addQueryItem('descr', '\n'.join(errorMessage))
        url.setQuery(query)

        executor = QDesktopServices()
        executor.openUrl(url)

    # Call the default handler
    sys.__excepthook__(type_, value, tback)
Beispiel #41
0
def exceptHook(type_, value, tback):
    stack = ''.join(traceback.format_exception(type_, value, tback))

    title = QApplication.translate("ExcpHook", "System error")
    text = QApplication.translate("ExcpHook",
                        "A system error occurred.\n"
                        "Do you want to send an error message to the author\n"
                        "(Google account required)?")
    msgBox = QMessageBox(QMessageBox.Information, title, text)
    msgBox.setDetailedText(stack)
    msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
    if msgBox.exec_() == QMessageBox.Yes:
        line = traceback.extract_tb(tback, 1)[0]
        subject = "[v%s] %s - %s:%d" % (version.Version, type_.__name__,
                                        line[0], line[1])

        errorMessage = []
        errorMessage.append("%s: %s" % (version.AppName, version.Version))
        errorMessage.append("OS: %s %s %s (%s)" % (platform.system(),
                                                   platform.release(),
                                                   platform.architecture()[0],
                                                   platform.version()))
        errorMessage.append("Python: %s" % platform.python_version())
        errorMessage.append("Qt: %s" % PYQT_VERSION_STR)
        errorMessage.append('')
        errorMessage.append(stack)

        url = QUrl('https://code.google.com/p/open-numismat/issues/entry')
        query = QUrlQuery()
        query.addQueryItem('summary', subject)
        query.addQueryItem('comment', '\n'.join(errorMessage))
        url.setQuery(query)

        executor = QDesktopServices()
        executor.openUrl(url)

    # Call the default handler
    sys.__excepthook__(type_, value, tback)
Beispiel #42
0
 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.webservice.post(host, port, path, data,
                     partial(self.on_refresh_access_token_finished, callback),
                     parse_response_type=None, mblogin=True, priority=True, important=True)
Beispiel #43
0
    def _sendRequest(self, url, params, headers={}):
        if self.asynchonous:

            if self.reply is not None:
                self.reply.finished.disconnect(self.reply_finished)
                self.reply.abort()
                self.reply = None

            url = QUrl(url)
            q = QUrlQuery(url)
            for key, value in params.items():
                q.addQueryItem(key, value)
            url.setQuery(q)
            QgsLogger.debug('Request: {}'.format(url.toEncoded()))
            request = QNetworkRequest(url)
            for key, value in headers.items():
                request.setRawHeader(key, value)
            self.reply = QgsNetworkAccessManager.instance().get(request)
            self.reply.finished.connect(self.reply_finished)

        else:
            response = urlopen(self.url + '?' + urllib.urlencode(params))
            data = json.load(response)
            self.load_data(data)
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')