def rank_source_file_reply(self):
""" 获取日排名请求返回 """
reply = self.sender()
request_url = reply.request().url().url()
# 解析出请求的品种
request_filename = request_url.rsplit("/", 1)[1]
request_variety = request_filename.split("_")[0]
if reply.error():
reply.deleteLater()
self.spider_finished.emit(
"获取{}排名数据文件。\n失败:{}".format(request_variety[:2],
str(reply.error())), True)
logger.error("获取{}排名数据文件失败了!".format(request_url[:2]))
return
save_path = os.path.join(
LOCAL_SPIDER_SRC,
'cffex/rank/{}_{}.csv'.format(request_variety,
self.date.strftime("%Y-%m-%d")))
file_data = reply.readAll()
file_obj = QFile(save_path)
is_open = file_obj.open(QFile.WriteOnly)
if is_open:
file_obj.write(file_data)
file_obj.close()
reply.deleteLater()
tip = "获取中金所{}_{}日持仓排名数据保存到文件成功!".format(
request_variety, self.date.strftime("%Y-%m-%d"))
if request_variety == "T":
tip = "获取中金所{}日所有品种持仓排名数据保存到文件成功!".format(
self.date.strftime("%Y-%m-%d"))
self.spider_finished.emit(tip, True)
self.event_loop.quit()
def slotTestStoped(self):
self.testStatus[0] = False
self.setItemEnable(True)
self.timer.stop()
self.updateMessage()
self.thread.quit()
# save Test log
if self.saveTestLog:
fileName = time.strftime("%Y_%m_%d.%H_%M_%S.",time.localtime())
if self.radioReboot.isChecked():
fileName += "reboot"
elif self.radioProvision:
fileName += "provision"
else:
fileName += "factoryReset"
fileName += ".htm"
if self.saveLogPath == "":
self.outputWarning("日志地址没有设置，无法保存")
else:
fileName = self.saveLogPath + "\\" + fileName
print(fileName)
file = QFile(fileName)
if not file.open(QIODevice.WriteOnly):
self.outputError("打开文件错误,保存日志失败")
return
byteArr = bytes(self.messageBox.toHtml(),"utf-8")
file.write(QByteArray(byteArr))
file.close()
def received_file(self):
""" 接收到文件 """
reply = self.sender()
# 从路径中解析要保存的位置
request_url = reply.request().url().url()
split_ = request_url.split("/{}/".format(self.sys_bit))
save_file_path = os.path.join(BASE_DIR, split_[1])
# 文件夹不存在创建
save_dir = os.path.split(save_file_path)[0]
if not os.path.exists(save_dir):
os.makedirs(save_dir)
file_data = reply.readAll()
if reply.error():
# print("更新错误", reply.error())
self.update_error = True
file_obj = QFile(save_file_path)
is_open = file_obj.open(QFile.WriteOnly)
if is_open:
file_obj.write(file_data)
file_obj.close()
else:
self.update_error = True
self.current_count += 1
self.update_process_bar.setValue(self.current_count)
reply.deleteLater()
if self.current_count >= self.update_count:
self.update_finished_restart_app()
def saveCache(self):
file = QFile("cache")
if not file.open(QIODevice.WriteOnly):
return
content = self.ipLineEdit.text() + "\n"
content += self.passwordLineEdit.text() + "\n"
content += self.userLineEdit.text() + "\n"
content += self.ver1LineEdit.text() + "\n"
content += self.dir1LineEdit.text() + "\n"
content += self.ver2LineEdit.text() + "\n"
content += self.dir2LineEdit.text() + "\n"
content += self.ver3LineEdit.text() + "\n"
content += self.dir3LineEdit.text() + "\n"
content += str(self.intervalSpinBox.value()) + "\n"
content += str(self.loopSpinBox.value()) + "\n"
if self.gxpAction.isChecked():
content += "gxpAction\n"
else:
content += "grp2602Action\n"
if self.radioReboot.isChecked():
content += "reboot\n"
elif self.radioProvision.isChecked():
content += "provision\n"
else:
content += "factory\n"
if self.radioHttp.isChecked():
content += "Http\n"
elif self.radioHttps.isChecked():
content += "Https\n"
elif self.radioTftp.isChecked():
content += "Tftp\n"
elif self.radioFtp.isChecked():
content += "Ftp\n"
elif self.radioFtps.isChecked():
content += "Ftps\n"
else :
content += "Window\n"
content += str(self.findCoreStop) + "\n"
content += str(self.cleanCacheSet) + "\n"
content += str(self.useApiTest) + "\n"
content += str(self.showTestProgress) + "\n"
content += str(self.showChrome) + "\n"
content += self.chromePath +"\n"
content += str(self.saveTestLog) +"\n"
content += self.saveLogPath +"\n"
content += self.coreDumpPath +"\n"
byteArr = bytes(content,"utf-8")
file.write(QByteArray(byteArr))
file.close()
def runReport(self, pid, method, par):
self.boolDirect = True
self.mtypeCall = "report"
self.mpid = pid
self.mmethod = method
self.mparams = par
#
bparams = self.prepareParams()
request = self.prepareRequest()
#
reply = self.data_request(request, bparams)
data = reply.readAll()
parseError = QJsonParseError()
resultObject = {}
resultObject["data"] = "error"
document = QJsonDocument.fromJson(data, parseError)
if parseError.error == True:
resultObject["data"] = "error"
else:
if document.isObject():
jv = document.object()
if jv.__contains__(
"result") == True and jv["result"].__class__() == []:
#tryton 4.0
#'result': ['pdf', {'base64':wwwwww, '__class__':'bytes'}, False,'Printis']
jre = jv["result"]
namesecs = "tryton_" + self.mpid + str(
QDateTime.currentMSecsSinceEpoch()) + "." + jre[0]
mdir = QDir(self.mDir + QDir.separator() + "tempReports")
if mdir.exists() == False:
s = QDir(self.mDir)
s.mkdir("tempReports")
filename = self.mDir + QDir.separator(
) + "tempReports" + QDir.separator() + namesecs
file = QFile(filename)
if file.open(QIODevice.WriteOnly) == False:
#error
self.signalResponse.emit(self.mpid, 7, {})
print("error", filename, file.errorString())
else:
bafile = QByteArray.fromBase64(
jre[1]["base64"].encode())
file.write(bafile)
file.close()
QDesktopServices.openUrl(QUrl(filename))
else:
if document.isArray() == True:
self.signalResponse.emit(self.mpid, 7, {})
self.processingData(data, reply)
def save_default_parameters(self):
base_path = Path(__file__).parent
settings_path = str(
(base_path / '../resources/PRINTER_SETTINGS.json').resolve())
settings_file = QFile(settings_path)
file_data = {}
if settings_file.open(QIODevice.ReadOnly | QIODevice.Text):
file_data = QJsonDocument.fromJson(
settings_file.readAll()).object()
settings_file.close()
if settings_file.open(QIODevice.ReadWrite | QIODevice.Text
| QIODevice.Truncate):
file_data["printer_type"] = "DLP"
file_data["dlp_settings"] = self.__default_parameters
settings_file.write(QJsonDocument(file_data).toJson())
settings_file.close()
class Receiver():
def __init__(self, socket):
self._socket = socket
self._transaction = None
self._sender = None
self._file_name = None
self._socket.readyRead.connect(self.start)
self._receiving_file = None
self._bytearray_to_file = QByteArray()
self._file_size = 0
def get_file_name(self):
return self._file_name
def get_file_size(self):
return self._file_size
def get_sender(self):
return self._sender
def start(self):
self._sender = self._socket.peerAddress()
stream = QDataStream(self._socket)
if (self._file_size == 0):
if (self._socket.bytesAvailable() < getsizeof(int)):
return
self._file_size = stream.readUInt32()
if (self._socket.bytesAvailable() < self._file_size):
return
self._file_name = stream.readString()
line = QByteArray()
line = self._socket.readAll()
directory = Path(Setup().get_download_dir())
if not (directory.exists() and directory.is_dir()):
directory.mkdir()
self._receiving_file = QFile(Setup().get_download_dir() +
str(self._file_name))
print(Setup().get_download_dir() + str(self._file_name))
if not (self._receiving_file.open(QIODevice.WriteOnly)):
print("can't open file")
return
self._receiving_file.write(line)
self._receiving_file.close()
self._socket.disconnectFromHost()
print("finished")
return self._receiving_file
def daily_source_file_reply(self):
reply = self.sender()
if reply.error():
reply.deleteLater()
self.spider_finished.emit("失败:" + str(reply.error()), True)
return
save_path = os.path.join(
LOCAL_SPIDER_SRC,
'czce/daily/{}.xls'.format(self.date.strftime("%Y-%m-%d")))
file_data = reply.readAll()
file_obj = QFile(save_path)
is_open = file_obj.open(QFile.WriteOnly)
if is_open:
file_obj.write(file_data)
file_obj.close()
reply.deleteLater()
self.spider_finished.emit(
"获取郑商所{}日交易数据源文件成功!".format(self.date.strftime("%Y-%m-%d")), True)
class FileDownload(QObject):
def __init__(self, manager: QNetworkAccessManager, url: str,
output_url: str):
super(FileDownload, self).__init__(None)
request = QNetworkRequest(url)
self.output_url = output_url
self.output = QFile(self.output_url)
self.logger = create_logger(__name__)
if not self.output.open(QIODevice.WriteOnly):
self.logger.info(
"Could not open: {url}".format(url=self.output_url))
return
self.current_download = manager.get(request)
self.current_download_progress = FileDownloadProgress()
self.current_download.downloadProgress.connect(
self.current_download_progress.update)
self.current_download.readyRead.connect(self.saveFile)
self.current_download.finished.connect(self.download_finished)
@Property(str, constant=True)
def outputUrl(self) -> str:
return self.output_url
@Property(QObject, constant=True)
def progress(self) -> QObject:
return self.current_download_progress
@Slot()
def saveFile(self) -> None:
self.output.write(self.current_download.readAll())
@Slot()
def download_finished(self) -> None:
self.output.close()
class DownloadDialog(QDialog):
"""Summary
A dialog to download file and display progression
Attributes:
source (QUrl): url of file to download
destination (QDir): destination folder of downloaded file
"""
def __init__(self, parent=None):
super().__init__(parent)
self.file_label = QLabel()
self.progress = QProgressBar()
self.info_label = QLabel()
self.btn_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.net = QNetworkAccessManager()
font = QFont()
font.setBold(True)
self.file_label.setFont(font)
v_layout = QVBoxLayout()
v_layout.addWidget(self.file_label)
v_layout.addWidget(self.progress)
v_layout.addWidget(self.info_label)
v_layout.addStretch()
v_layout.addWidget(self.btn_box)
self.btn_box.accepted.connect(self.close)
self.btn_box.rejected.connect(self.cancel)
self.btn_box.button(QDialogButtonBox.Ok).setVisible(False)
self.setLayout(v_layout)
self.setFixedSize(450, 150)
self.setWindowTitle(self.tr("Download file"))
def set_source(self, url: QUrl):
"""Set file url to download
Args:
url (QUrl)
"""
self.source = url
self.file_label.setText(self.source.fileName())
def set_destination(self, directory: QDir):
"""Set folder path where download the file
Args:
directory (QDir)
"""
self.destination = directory
def start(self):
""" Start downloading the file specify by set_source
"""
filepath = self.destination.absoluteFilePath(self.source.fileName())
if QFile(filepath).exists():
QFile.remove(filepath)
self._file = QFile(filepath)
# open the file to write in
if self._file.open(QIODevice.WriteOnly):
print("open file", filepath)
# Create a Qt Request
request = QNetworkRequest()
request.setUrl(self.source)
self.time = QTime.currentTime()
self.reply = self.net.get(request)
# Connect reply to different slots
self.reply.downloadProgress.connect(self.on_update_progress)
self.reply.finished.connect(self.on_finished)
self.reply.error.connect(self.on_error)
def cancel(self):
"""Cancel download
"""
if hasattr(self, "reply"):
self.reply.abort()
self._file.remove()
self.close()
@Slot(int, int)
def on_update_progress(self, read, total):
"""This methods is called by self.reply.downloadProgress signal
Args:
read (int): Number of bytes readed
total (int): Total bytes to download
"""
if read <= 0:
return
if self.reply.error() != QNetworkReply.NoError:
return
self._file.write(self.reply.readAll())
# compute speed
duration = self.time.secsTo(QTime.currentTime()) + 1
speed = read / duration
remaining = (total - read) / speed
h_remaining = QTime(0, 0, 0, 0).addSecs(remaining).toString()
h_total = self.human_readable_bytes(total)
h_read = self.human_readable_bytes(read)
h_speed = self.human_readable_bytes(speed) + "/sec"
self.info_label.setText(
f"Time remaining {h_remaining} - {h_read} of {h_total} ({h_speed})"
)
# Set progression
self.progress.setRange(0, total)
self.progress.setValue(read)
@Slot()
def on_finished(self):
"""This methods is called by self.reply.finished signal
"""
if self.reply.error() == QNetworkReply.NoError:
self._file.close()
self.reply.deleteLater()
self.btn_box.button(QDialogButtonBox.Ok).setVisible(True)
@Slot(QNetworkReply.NetworkError)
def on_error(self, err: QNetworkReply.NetworkError):
"""This method is called by self.reply.error signal
Args:
err (QNetworkReply.NetworkError)
"""
self.reply.deleteLater()
def human_readable_bytes(self, num, suffix="B"):
for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
if abs(num) < 1024.0:
return "%3.1f%s%s" % (num, unit, suffix)
num /= 1024.0
return "%.1f%s%s" % (num, "Yi", suffix)
def rechargeNet(self, preferences, username):
#version 1.1 up thesamodule
data = self.m_qjsonnetwork.callDirect(
"version internal", "model.thesamodule.config.search_read",
[[], 0, 1, [], ["internal_version"], preferences])
if not data["data"] == "error":
self.internal_version = data["data"]["result"][0][
"internal_version"]
if float(self.internal_version) > 1.0:
data = self.m_qjsonnetwork.callDirect(
"cachedel", "model.thesamodule.config.search_read",
[[], 0, 1, [], ["deletecache"], preferences])
if not data["data"] == "error":
if data["data"]["result"][0]["deletecache"] == True:
self.actionCache_ = "deleteOnCompleted"
else:
self.actionCache_ = "notDelete"
sysdir = QDir(self.mDir + QDir.separator() + _dirSystem)
DIR_QML_SYS = sysdir.path()
DIR_QML_SYS_LOST = DIR_QML_SYS + QDir.separator() + "lost"
sysdirlost = QDir(DIR_QML_SYS_LOST)
#revisar folder systemnet
if sysdir.exists() == False:
s = QDir(self.mDir)
s.mkdir(_dirSystem)
#revisar folder systemnet lost
if sysdirlost.exists() == False:
sl = QDir(DIR_QML_SYS)
sl.mkdir("lost")
#find all files en folder net
listSysFiles = os.listdir(DIR_QML_SYS)
if "lost" in listSysFiles:
listSysFiles.remove("lost")
#
data = {}
data["data"] = "error"
if float(self.internal_version) > 1.1:
data = self.m_qjsonnetwork.callDirect(
"findforuser", "model.thesamodule.usersfolder.search_read", [[
"AND", ["users.user.name", "=", username],
["activefolder", "=", True]
], 0, 1, [], ["qmlfiles"], preferences])
if not data["data"] == "error":
result = data["data"]["result"]
if len(result) > 0:
idfiles = result[0]["qmlfiles"]
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.read",
[idfiles, [
"checksum",
"filename",
], preferences])
if len(idfiles) == 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 15, {"noqmlfiles": ""})
else: #buscar default
data = self.m_qjsonnetwork.callDirect(
"findforuser",
"model.thesamodule.usersfolder.search_read", [[
"AND", ["type", "=", "default"],
["activefolder", "=", True]
], 0, 1, [], ["qmlfiles"], preferences])
if not data["data"] == "error":
result = data["data"]["result"]
if len(result) > 0:
idfiles = result[0]["qmlfiles"]
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.read", [
idfiles, [
"checksum",
"filename",
], preferences
])
if len(idfiles) == 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 15, {"noqmlfiles": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 12, {"noqmlfiles": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 13, {"error": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 13, {"error": ""})
else:
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.search_read",
[[], 0, 1000, [], ["checksum", "filename"], preferences])
if not data["data"] == "error":
resultnet = data["data"]["result"]
mapnet = {}
mapids = {}
listNetFiles = []
for file in resultnet:
mapnet[file["filename"]] = file["checksum"]
mapids[file["filename"]] = file["id"]
listNetFiles.append(file["filename"])
#buscar faltantes en system y los updates
#buscar los que ya no deben estar
mapsysnet = {}
listToUpdate = set() #new or update
listToErase = []
for file in listSysFiles:
try:
with open(DIR_QML_SYS + QDir.separator() + file,
"rb") as binary_file:
data = binary_file.read()
chek = hashlib.md5(data).hexdigest()
mapsysnet[file] = chek
except:
listToUpdate.add(file)
for file in listNetFiles:
if file in listSysFiles:
if mapnet[file] != mapsysnet[file]:
listToUpdate.add(file) # update
else:
listToUpdate.add(file) # new
for file in listSysFiles:
if not file in listNetFiles:
listToErase.append(file) # erase
listToUpdate = list(listToUpdate)
ids = []
for file in listToUpdate:
ids.append(mapids[file])
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep2", "model.thesamodule.thesamodule.read",
[ids, [
"filebinary",
"filename",
], preferences])
errors = []
if not data["data"] == "error":
resultnet = data["data"]["result"]
for file in resultnet:
filename = DIR_QML_SYS + QDir.separator(
) + file["filename"]
qfile = QFile(filename)
if qfile.open(QIODevice.WriteOnly) == False:
errors.append(filename)
print("error", filename, qfile.errorString())
else:
print("update", file["filename"])
bafile = QByteArray.fromBase64(
file["filebinary"]["base64"].encode())
qfile.write(bafile)
qfile.close()
if len(errors) > 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 33, {"error": errors})
return False
#erase
for file in listToErase:
print("moviendo", file)
shutil.move(DIR_QML_SYS + QDir.separator() + file,
DIR_QML_SYS_LOST + QDir.separator() + file)
return True
else:
#erase all files, no conexion con thesa module
for file in listSysFiles:
print("moviendo", file)
shutil.move(DIR_QML_SYS + QDir.separator() + file,
DIR_QML_SYS_LOST + QDir.separator() + file)
self.m_qjsonnetwork.signalResponse.emit("systemnet", 34,
{"error": ""})
return False
def save_current_parameters(self):
current_parameters = {
'printer_setup': self.printer_setup,
'projector_setup': self.projector_setup,
'motor_setup': self.motor_setup,
# Support Parameters
'support_thickness (mm)': self.support_thickness, # mm
'support_exposure (ms)': self.support_exposure, # ms
'support_amplitude': self.support_amplitude,
'support_burn_layers': self.support_burn_layers,
'support_burn_exposure (ms)': self.support_burn_exposure, # ms
'support_burn_amplitude': self.support_burn_amplitude,
# Features Parameters
'features_thickness (mm)': self.features_thickness, # mm
'features_exposure (ms)': self.features_exposure, # ms
'features_amplitude': self.features_amplitude,
'features_burn_layers': self.features_burn_layers,
'features_burn_exposure (ms)': self.features_burn_exposure, # ms
'features_burn_amplitude': self.features_burn_amplitude,
# Advanced Parameters
'incremental_thickness': self.incremental_thickness,
'incremental_exposure': self.incremental_exposure,
'incremental_amplitude': self.incremental_amplitude,
'starting_incremental_thickness (mm)':
self.starting_incremental_thickness, # mm
'incremental_step_thickness (mm)':
self.incremental_step_thickness, # mm
'starting_incremental_exposure (ms)':
self.starting_incremental_exposure, # ms
'incremental_step_exposure (ms)':
self.incremental_step_exposure, # ms
'starting_incremental_amplitude':
self.starting_incremental_amplitude,
'incremental_step_amplitude': self.incremental_step_amplitude,
'fixed_layer': self.fixed_layer,
'grayscale_correction': self.grayscale_correction,
'grayscale_alpha': self.grayscale_alpha,
'grayscale_beta': self.grayscale_beta,
'grayscale_gamma': self.grayscale_gamma,
# Others
'projector_amplitude': self.projector_amplitude,
'feed_rate (mm/min)': self.__motor_controller.feed_rate, # mm/min
'spindle_pitch_microns': self.spindle_pitch_microns,
'motor_steps_per_revolution': self.motor_steps_per_revolution,
'projector_feed_rate (mm/min)':
self.__motor_controller.projector_feed_rate,
'repositioning_delay (ms)':
self.__motor_controller.repositioning_delay, # ms
'repositioning_offset (mm)':
self.__motor_controller.repositioning_offset, # mm
'projector_pixel_size (mm)': self.projector_pixel_size, # mm
'projector_width': self.projector_width,
'projector_height': self.projector_height,
'horizontal_mirror': self.__projector_controller.horizontal_mirror,
'vertical_mirror': self.__projector_controller.vertical_mirror,
'samples_per_pixel': self.samples_per_pixel
}
base_path = Path(__file__).parent
log_path = str((base_path / '../resources/PRINT_LOG.json').resolve())
log_file = QFile(log_path)
file_data = {}
# if log_file.open(QIODevice.ReadOnly | QIODevice.Text):
# file_data = QJsonDocument.fromJson(log_file.readAll()).object()
# log_file.close()
if log_file.open(QIODevice.ReadWrite | QIODevice.Append):
# Print Job Parameters
file_data['date (yyyy.MM.dd)'] = self.printing_date
file_data['time (hh.mm.ss)'] = self.printing_time
file_data['username'] = self.username
file_data['print_job_name'] = self.print_job_name
file_data['print_job_status'] = self.print_status
file_data['total_layers'] = self.number_of_layers
file_data['support_layers'] = len(self.support_file_names)
file_data['features_layers'] = len(self.features_file_names)
file_data['printed_layers'] = self.current_layer
file_data["printer_type"] = "DLP"
if self.print_status == "FAILED":
file_data["error_message"] = self.error_message
file_data["dlp_settings"] = current_parameters
log_file.write(QJsonDocument(file_data).toJson())
log_file.close()
