def run_dosage(self, pump_type):
self.pump_on = not self.pump_on
if not self.pump_on:
url = f"http://192.168.1.35:5000/runPump?type={pump_type}"
print("Starting Dosage Request")
request = QtNetwork.QNetworkRequest(QUrl(url))
self.nam.get(request)
else:
url = f"http://192.168.1.35:5000/stopPump?type={pump_type}"
print("Finishing Dosage Request")
request = QtNetwork.QNetworkRequest(QUrl(url))
self.nam.get(request)
def doRequestMenu(self):
url = self.setting.value("baseURL", "")
url += "/menu/?sellerID=" + str(self.setting.value("sellerID", ""))
req = QtNetwork.QNetworkRequest(QUrl(url))
reply = self.nam.get(req)
reply.finished.connect(self.handleResponseMenu)
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 makeOWMApiCall(self):
print("OWM API Call")
url = "https://api.openweathermap.org/data/2.5/weather?id=" + self.owmCityID + "&units=" + self.owmUnit + "&lang=" + self.owmLanguage + "&appid=" + self.owmAPIKey
req = QtNetwork.QNetworkRequest(QtCore.QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleOWMResponse)
self.nam.get(req)
def doRequestOrder(self):
# Update the Loading Text
self.totalPriceLabel.setText("Total Price: {}".format(
formatRupiah(self.totalPrice)))
self.messageLabel.setText("Memproses Order (1/2)")
QCoreApplication.processEvents()
data = QByteArray()
data.append("paymentID=0")
data.append("&")
data.append("amount=")
data.append(str(self.totalPrice))
data.append("&")
data.append("orderStatus=placed")
# print("DO REQUEST ORDER:")
# print(data)
self.mylogger.debug("Req Order: {}".format(data))
setting = QSettings()
url = setting.value("baseURL", "")
url += "/order/"
# url = "http://127.0.0.1:8000/api/order/"
req = QtNetwork.QNetworkRequest(QUrl(url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
reply = self.nam.post(req, data)
reply.finished.connect(self.handleResponseOrder)
def doRequestPayment(self):
# Update the Loading Text
self.messageLabel.setText(
"Memproses Pembayaran. Jangan Keluarkan Kartu!")
QCoreApplication.processEvents()
data = QByteArray()
data.append("cardID=")
# TODO Change this for real app
# data.append(self.cardID[-8:])
# data.append("1234")
data.append("&")
data.append("amount=")
data.append(str(self.totalPrice))
data.append("&")
data.append("orderID=")
data.append(str(self.orderID))
# print("DO REQUEST PAYMENT:")
# print(data)
self.mylogger.debug("Req Payment: {}".format(data))
setting = QSettings()
url = setting.value("baseURL", "")
url += "/payment/"
# url = "http://127.0.0.1:8000/api/order/"
req = QtNetwork.QNetworkRequest(QUrl(url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
reply = self.nam.post(req, data)
reply.finished.connect(self.handleResponsePayment)
def make_request(self, url, data, filename):
print(f"Making request to {url}")
# Create the request object
self.request = qtn.QNetworkRequest(url)
# create the multipart object
self.multipart = qtn.QHttpMultiPart(qtn.QHttpMultiPart.FormDataType)
# Write the key-value data to the multipart
json_string = json.dumps(data)
http_part = qtn.QHttpPart()
http_part.setHeader(qtn.QNetworkRequest.ContentTypeHeader, 'text/json')
http_part.setBody(json_string.encode('utf-8'))
self.multipart.append(http_part)
# Write the file data to the multipart
if filename:
file_part = qtn.QHttpPart()
filedata = open(filename, 'rb').read()
file_part.setHeader(
qtn.QNetworkRequest.ContentDispositionHeader,
f'form-data; name="attachment"; filename="{filename}"')
file_part.setBody(filedata)
self.multipart.append(file_part)
# Post the request with the form data
self.nam.post(self.request, self.multipart)
def _handleXmlReplyFinished(self, element, reply):
"""React to finished XML replies. These replies do not contain the covers but information about
the album in Last.fm's XML-format. This method will get the cover URLs from XML and start new
requests for them."""
try:
if reply.error() != QtNetwork.QNetworkReply.NoError:
# an error occurred and has been handled by _handleNetworkError
return
urls = self._getURLsFromXml(reply.readAll())
for url in urls:
imageReply = application.network.get(
QtNetwork.QNetworkRequest(url))
imageReply.finished.connect(
functools.partial(self._handleImageReplyFinished, element,
imageReply))
imageReply.error.connect(
functools.partial(self._handleNetworkError, imageReply))
self.imageReplies[element].append(imageReply)
except RuntimeError: # parsing xml failed
url = reply.request().url().toString()
self.error.emit(
"Cannot fetch cover URL from XML at '{}'.".format(url))
finally:
self.xmlReplies[element].remove(reply)
if not self.isBusy(element):
self.finished.emit(element)
def addRespHandler(reply):
if (reply.error() == QtNetwork.QNetworkReply.NoError):
response_string = str(reply.readAll(), 'utf-8').strip()
if (not response_string):
raise ValueError(
'Response string is empty'
) #this error happens when we call the function a second time D:
response_array = json.loads(
response_string
) #not sure why we need strip() here but not in getJsonList
self.responses_raw += response_array
#TODO: might be better to send signal to AppWindow and let it handle this?
self.appWindow.ui.progressBar.setValue(
self.currentRequest / self.totalRequests * 80.0)
if (len(response_array) == 100):
url.args['offset'] += 100
print('Request: ', url.url)
self.currentRequest += 1
self.netManager.get(
QtNetwork.QNetworkRequest(QUrl(url.url)))
else:
self.appWindow.ui.statusBar.showMessage(
'Cleaning up posts, this may take a while... ')
self.__startPP(
self.additionalPostProcessor, convertCsv,
self.additionalPostProcessor.cleanResponseList)
else:
print('Error occurred: ', reply.error())
print(reply().errorString())
def __downloadChunk(self, url, handler):
self.appWindow.ui.statusBar.showMessage(
'Downloading, this may take a while... ')
self.resetDownloader()
assert (self.targetPostCount >=
-1), 'Assertion failed: postCount invalid'
if (self.targetPostCount == -1):
self.targetPostCount = sys.maxsize #this might be very bad practice D:
info = self.__probeRequest(url)
if (info.code != 200):
print('Error: server responded with code {}'.format(info.code))
raise ConnectionError('Server responded with code {}'.format(
info.code))
elif (info.totalPosts == 0):
print('Error: no posts found with the given parameter')
raise ValueError('No posts found with the given parameter')
print('{} posts found'.format(info.totalPosts))
self.totalRequests = math.ceil(
min(info.totalPosts, self.targetPostCount) / 100)
self.netManager.finished.connect(handler)
url.args['per_page'] = 100
url.args['offset'] = 0
print('Request: ', url.url)
self.currentRequest += 1
self.netManager.get(QtNetwork.QNetworkRequest(QUrl(url.url)))
def updateCurrentlyPlaying(self):
"""
Update information of currenlty playing track
"""
cpb = self._spotify.current_playback()
if cpb is not None:
if cpb['is_playing'] is True:
self._play_pause.setText("Pause")
self._play_pause_button.setIcon(Assets().pause_icon)
else:
self._play_pause.setText("Play")
self._play_pause_button.setIcon(Assets().play_icon)
if ('item' in cpb) and (cpb['item'] is not None):
self._current_title = cpb['item']['name']
self._current_artists = []
for a in cpb['item']['artists']:
self._current_artists.append(a['name'])
self.updateCurrentlyPlayingTitle()
images = cpb['item']['album']['images']
for img in images:
if (img['height'] >= self.ALBUM_IMAGE_HT and
img['height'] <= 600):
img_url = img['url']
img_req = QtNetwork.QNetworkRequest(QtCore.QUrl(img_url))
self._nam.get(img_req)
def connectToSpotify(self):
"""
Connect to Spotify via our local HTTP server
"""
spotify_req = QtNetwork.QNetworkRequest(
QtCore.QUrl("http://localhost:{}".format(server.port)))
self._nam.get(spotify_req)
def _start_request_continue(self, method, host, port, path, data, handler, xml,
mblogin=False, cacheloadcontrol=None, refresh=None,
access_token=None, queryargs=None):
url = build_qurl(host, port, path=path, queryargs=queryargs)
request = QtNetwork.QNetworkRequest(url)
if mblogin and access_token:
# access_token must not be unicode - PyQt5 doesn't like it.
request.setRawHeader(b"Authorization", ("Bearer %s" % string_(access_token)).encode('utf-8'))
if mblogin or (method == "GET" and refresh):
request.setPriority(QtNetwork.QNetworkRequest.HighPriority)
request.setAttribute(QtNetwork.QNetworkRequest.CacheLoadControlAttribute,
QtNetwork.QNetworkRequest.AlwaysNetwork)
elif method == "PUT" or method == "DELETE":
request.setPriority(QtNetwork.QNetworkRequest.HighPriority)
elif cacheloadcontrol is not None:
request.setAttribute(QtNetwork.QNetworkRequest.CacheLoadControlAttribute,
cacheloadcontrol)
request.setRawHeader(b"User-Agent", USER_AGENT_STRING.encode('utf-8'))
if xml:
request.setRawHeader(b"Accept", b"application/xml")
if data is not None:
if method == "POST" and host == config.setting["server_host"] and xml:
request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/xml; charset=utf-8")
else:
request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
send = self._request_methods[method]
reply = send(request, data.encode('utf-8')) if data is not None else send(request)
self._remember_request_time((host, port))
self._active_requests[reply] = (request, handler, xml, refresh)
def upload_file(file_to_upload, post_url, key, callback):
"""Method for uploading files to GIS Cloud"""
zip_part = QtNetwork.QHttpPart()
zip_part_content_disposition = QByteArray(
'form-data; name="upfile"; filename="{}"'.format(
os.path.basename(file_to_upload)).encode('utf-8'))
zip_part.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
QByteArray(b'application/json'))
zip_part.setHeader(QtNetwork.QNetworkRequest.ContentDispositionHeader,
zip_part_content_disposition)
file_handler = QFile(file_to_upload)
file_handler.open(QIODevice.ReadOnly)
zip_part.setBodyDevice(file_handler)
multi_part = QtNetwork.QHttpMultiPart(
QtNetwork.QHttpMultiPart.FormDataType)
file_handler.setParent(multi_part)
multi_part.append(zip_part)
request = QtNetwork.QNetworkRequest()
request.setRawHeader(QByteArray(b'X-GIS-CLOUD-APP'),
GISCloudNetworkHandler.app_id.encode("utf-8"))
result = GISCloudNetworkHandler.blocking_request(
GISCloudNetworkHandler.POST, post_url, key, multi_part, request,
callback)
return result
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 checkWeather(self):
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
req = QtNetwork.QNetworkRequest(self.url)
self.nam.get(req)
def run(self):
logi( self.url)
if self.timeout_second>0:
self.timer = QTimer()
self.timer.timeout.connect(self._on_timeout)
self.timer.start(self.timeout_second*1000)
self._request = QtNetwork.QNetworkRequest(QUrl(self.url))
# if self._http_user and self._http_password:
# self._request.setRawHeader(b'Authorization', b'Basic ' + base64.b64encode("{}:{}".format(self._http_user, self._http_password).encode()))
self._request.setRawHeader(b'Connection', b'keep-alive')
for key in self._header.keys():
self._request.setRawHeader(key.encode('utf-8'), self._header[key].encode('gbk'))
if self.session_id != -1:
self._request.setRawHeader(b"session_id", str(self.session_id).encode('utf-8'))
if self._data:
self._request.setRawHeader(b'Content-Type', b'application/octet-stream')
self._reply = self._qnam.post(self._request, self._data)
if self._on_upload_progress:
self._reply.uploadProgress.connect(self._on_upload_progress)
else:
self._reply = self._qnam.get(self._request)
self._reply.finished.connect(self._on_response)
self._reply.error.connect(self._on_error)
def fetch(self, elements):
for element in elements:
if tags.get('artist') not in element.tags:
self.error.emit(
self.
tr("Cannot fetch a cover for an element without artist tag."
))
self.finished.emit(element)
elif (
tags.ALBUM not in element.tags
# for containers allow to use the title
and
(not element.isContainer() or tags.TITLE not in element.tags)):
self.error.emit(
self.
tr("Cannot fetch a cover for an element without album tag."
))
self.finished.emit(element)
else:
for url in self._getLastFmURLs(element):
reply = application.network.get(
QtNetwork.QNetworkRequest(url))
reply.finished.connect(
functools.partial(self._handleXmlReplyFinished,
element, reply))
reply.error.connect(
functools.partial(self._handleNetworkError, reply))
self.xmlReplies[element].append(reply)
def fileLister(self, url, dir):
try:
self.macRequest = QtNetwork.QNetworkRequest(
QUrl(url + 'rr_filelist?dir=' + dir))
self.macRequest.setRawHeader(b'User-Agent',
b'Cura Plugin Nautilus')
self.macRequest.setRawHeader(b'Accept',
b'application/json, text/javascript')
self.macRequest.setRawHeader(b'Connection', b'keep-alive')
#self.gitRequest.setRawHeader(b"User-Agent", b"Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7 (.NET CLR 3.5.30729)")
self.macroReply = self._qnam.get(self.macRequest)
loop = QEventLoop()
self.macroReply.finished.connect(loop.quit)
loop.exec_()
reply_body = bytes(self.macroReply.readAll()).decode()
Logger.log("d",
self._name_id + " | Status received | " + reply_body)
return reply_body
except:
Logger.log(
"i", "couldn't connect to the printer: " +
str(traceback.format_exc()))
return '0'
def doRequestOrderDetail(self):
# print(self.orderList)
# Update the Loading Text
self.messageLabel.setText("Memproses Order (2/2)")
QCoreApplication.processEvents()
# Add Order ID value to each of item in orderList
for item in self.orderList:
item['orderID'] = str(self.orderID)
data = QByteArray()
data.append(json.dumps(self.orderList))
# print("DO REQUEST ORDER DETAIL:")
# print(data)
self.mylogger.debug("Req OrderDetail: {}".format(data))
setting = QSettings()
url = setting.value("baseURL", "")
url += "/orderdetail/"
req = QtNetwork.QNetworkRequest(QUrl(url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/json")
reply = self.nam.post(req, data)
reply.finished.connect(self.handleResponseOrderDetail)
def internal_send_line(self, line):
request = QtNetwork.QNetworkRequest()
url = QtCore.QUrl(f"http://{HOSTNAME}/command?commandText={line}")
request.setUrl(url)
self.manager.get(request)
self.changeState(State.STATE_SENDING_COMMAND)
return True
def doRequestCancelOrder(self):
# Update the Loading Text
self.messageLabel.setText("Update Order")
QCoreApplication.processEvents()
temp = {
'paymentID': 0,
'amount': self.totalPrice,
'orderStatus': "canceled"
}
data = QByteArray()
data.append(json.dumps(temp))
# print("DO REQUEST CANCEL ORDER:")
# print(data)
self.mylogger.debug("Req Cancel Order: {}".format(data))
setting = QSettings()
url = setting.value("baseURL", "")
url += "/order/" + str(self.orderID) + "/"
# print("URL: {}".format(url))
# url = "http://127.0.0.1:8000/api/order/"
req = QtNetwork.QNetworkRequest(QUrl(url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/json")
reply = self.nam.put(req, data)
reply.finished.connect(self.handleResponseCancelOrder)
def retrieve_latest_version(self):
''' return latest version from server '''
req = QtNetwork.QNetworkRequest(QtCore.QUrl(self.__url))
self.__qnam = QtNetwork.QNetworkAccessManager()
self.__res = self.__qnam.get(req)
self.__res.finished.connect(self.processRes)
self.__res.error.connect(self.processErr)
def request(request_type,
url,
key,
payload=None,
handle_reply=None,
handle_error=None,
default_request=None):
"""This is an blocking request method we use in threads"""
# pylint: disable=R0913
if not default_request:
default_request = GISCloudNetworkHandler.default_request
req = QtNetwork.QNetworkRequest(default_request)
if key:
req.setRawHeader(QByteArray(b'API-Key'),
QByteArray(str(key).encode("utf-8")))
req.setUrl(QUrl(url))
if payload:
payload = QByteArray(json.dumps(payload).encode("utf-8"))
if request_type == GISCloudNetworkHandler.POST:
reply = QgsNetworkAccessManager.instance().post(req, payload)
else:
reply = QgsNetworkAccessManager.instance().get(req)
handler = GISCloudNetworkHandler(reply, handle_reply, handle_error)
return handler
def update_messages(self):
if self.isNotRequested:
self.isNotRequested = False
request = QtNetwork.QNetworkRequest(
QtCore.QUrl(self.url + 'messages?after=' + str(self.after)))
self.network.get(request)
return
def _send(self, command, query=None, next_stage=None, data=None):
enc_query = urllib.parse.urlencode(query or dict())
if enc_query:
command += '?' + enc_query
self._request = QtNetwork.QNetworkRequest(
QUrl(self._url + "rr_" + command))
self._request.setRawHeader(b'User-Agent', b'Cura Plugin DuetRRF')
self._request.setRawHeader(b'Accept',
b'application/json, text/javascript')
self._request.setRawHeader(b'Connection', b'keep-alive')
if self._http_user and self._http_password:
self._request.setRawHeader(
b'Authorization', b'Basic ' + base64.b64encode("{}:{}".format(
self._http_user, self._http_password).encode()))
if data:
self._request.setRawHeader(b'Content-Type',
b'application/octet-stream')
self._reply = self._qnam.post(self._request, data)
self._reply.uploadProgress.connect(self._onUploadProgress)
else:
self._reply = self._qnam.get(self._request)
if next_stage:
self._reply.finished.connect(next_stage)
self._reply.error.connect(self._onNetworkError)
def download_nodes_list():
url = 'https://nodes.tox.chat/json'
s = settings.Settings.get_instance()
if not s['download_nodes_list']:
return
if not s['proxy_type']: # no proxy
try:
req = urllib.request.Request(url)
req.add_header('Content-Type', 'application/json')
response = urllib.request.urlopen(req)
result = response.read()
save_nodes(result)
except Exception as ex:
log('TOX nodes loading error: ' + str(ex))
else: # proxy
netman = QtNetwork.QNetworkAccessManager()
proxy = QtNetwork.QNetworkProxy()
proxy.setType(QtNetwork.QNetworkProxy.Socks5Proxy if s['proxy_type'] ==
2 else QtNetwork.QNetworkProxy.HttpProxy)
proxy.setHostName(s['proxy_host'])
proxy.setPort(s['proxy_port'])
netman.setProxy(proxy)
try:
request = QtNetwork.QNetworkRequest()
request.setUrl(QtCore.QUrl(url))
reply = netman.get(request)
while not reply.isFinished():
QtCore.QThread.msleep(1)
QtCore.QCoreApplication.processEvents()
data = bytes(reply.readAll().data())
save_nodes(data)
except Exception as ex:
log('TOX nodes loading error: ' + str(ex))
def validate_token(self, token: str):
"""Validates a token."""
# Declarations
req = QtNetwork.QNetworkRequest(QtCore.QUrl('https://id.twitch.tv/oauth2/validate'))
req.setRawHeader(b'Authorization', b'OAuth ' + token.encode())
return self._request(op='GET', request=req).json()
def doRequest(self):
url = 'http://webcode.me' # url to receive html from
req = QtNetwork.QNetworkRequest(QUrl(url)) #request instance
self.nam = QtNetwork.QNetworkAccessManager() # create the manager object
self.nam.finished.connect(self.handleResponse) # handle response when requist is finished
self.nam.get(req)
def exit_calibration_mode(self, pump_type):
url = f"http://192.168.1.35:5000/calibrationModeOff?type={pump_type}"
print("Exiting Calibration Mode")
request = QtNetwork.QNetworkRequest(QUrl(url))
loop = QEventLoop()
resp = self.nam.get(request)
resp.finished.connect(loop.quit)
self.load_server()
