def updateZoneTable(self, zone, isNew):
if (isNew):
self.tables[TID_Z].insertRow(0)
# "Name" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(zone.name)
item.setData(5, zone.xmlId)
self.tables[TID_Z].setItem(0, 0, item)
# "Module ID" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(str(zone.hwId))
self.tables[TID_Z].setItem(0, 1, item)
# "Threshold" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(str(zone.threshold))
self.tables[TID_Z].setItem(0, 2, item)
else:
items = self.tables[TID_Z].selectedItems()
items[0].setText(zone.name)
items[1].setText(str(zone.hwId))
items[2].setText(str(zone.threshold))
def post_alert(self, id, msg, quiet=False):
if id in self.__hidden_uavs:
return #don't post alerts on UAVs I've said I don't care about
if id not in self.__alerts:
self.__alerts[id] = {}
self.__alerts[id]["time"] = time.time()
if "alerts" not in self.__alerts[id]:
self.__alerts[id]["alerts"] = []
if msg not in self.__alerts[id]["alerts"]:
self.__alerts[id]['alerts'].append(msg)
if quiet is False:
self.__speech.say(msg + " alert on " + str(id))
#already have alerts for this UAV?
if 'row' in self.__alerts[id]:
row = self.__alerts[id]['row']
else:
#put alert in alert table
self.__ui.tbl_alerts.insertRow(self.__ui.tbl_alerts.rowCount())
row = self.__ui.tbl_alerts.rowCount()-1
next_item = QTableWidgetItem()
next_item.setData(Qt.DisplayRole, id)
self.__ui.tbl_alerts.setItem(row, self.__ALRT_ID_COL, next_item)
self.__ui.tbl_alerts.setItem(row, self.__ALRT_MSGS_COL,
QTableWidgetItem())
self.__alerts[id]['row'] = row
self.__ui.tbl_alerts.item(row, self.__ALRT_MSGS_COL).setText(
",".join(self.__alerts[id]["alerts"]))
def append_items(self, item_data_list):
for data in item_data_list:
pathname = data["pathname"]
path,name = os.path.split(pathname)
character = ""
if "character" in data:
character = data["character"]
count = self.table.rowCount()
self.table.insertRow(count)
# thumbnail
img = QImage()
img.load(pathname)
thumbnail_item = QTableWidgetItem()
thumbnail_item.setTextAlignment(Qt.AlignCenter);
thumbnail_item.setData(Qt.DecorationRole, QPixmap.fromImage(img));
self.table.setItem(count, 0, thumbnail_item)
# name
name_item = QTableWidgetItem(name)
name_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(count, 1, name_item)
# character
self.table.setItem(count, 2, QTableWidgetItem(character))
self.image_config.append({
"image":pathname,
"character":character,
})
self.table.resizeColumnToContents(0)
def createGUI(self):
tableData = [
("Alice", QColor('aliceblue')),
("Neptun", QColor('aquamarine')),
("Ferdinand", QColor('springgreen'))
]
table = QTableWidget(3, 2)
table.setHorizontalHeaderLabels(["Name", "Hair Color"])
table.verticalHeader().setVisible(False)
table.resize(150, 50)
for i, (name, color) in enumerate(tableData):
nameItem = QTableWidgetItem(name)
colorItem = QTableWidgetItem()
colorItem.setData(Qt.DisplayRole, color)
table.setItem(i, 0, nameItem)
table.setItem(i, 1, colorItem)
table.resizeColumnToContents(0)
table.horizontalHeader().setStretchLastSection(True)
layout = QGridLayout()
layout.addWidget(table, 0, 0)
self.setLayout(layout)
self.setWindowTitle("Color Editor Factory")
def set_table_info(self):
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
if not self.table_items:
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
if table_typle[3] > 0:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(252, 141, 141, 255))
for column in range(1, len(table_typle)):
if isinstance(table_typle[column], Decimal):
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(table_typle[column]))
elif isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
item.setData(5, table_typle[0])
item.setBackground(color)
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 1, item)
def of_tree_select_order(self, order):
query = """SELECT `order`.Id, clients.Name, clients_actual_address.Name, `order`.Number_Order, `order`.Date_Shipment, `order`.Number_Doc
FROM `order` LEFT JOIN clients ON `order`.Client_Id = clients.Id
LEFT JOIN clients_actual_address ON `order`.Clients_Adress_Id = clients_actual_address.Id
WHERE `order`.Id = %s"""
sql_info = my_sql.sql_select(query, (order[1],))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения информации о заказе", sql_info.msg, QMessageBox.Ok)
return False
if not sql_info:
return False
order = sql_info[0]
self.tw_order.insertRow(self.tw_order.rowCount())
table_item = QTableWidgetItem(str(order[1]))
table_item.setData(-1, order[0])
self.tw_order.setItem(self.tw_order.rowCount()-1, 0, table_item)
table_item = QTableWidgetItem(str(order[2]))
table_item.setData(-1, order[0])
self.tw_order.setItem(self.tw_order.rowCount()-1, 1, table_item)
table_item = QTableWidgetItem(str(order[3]))
table_item.setData(-1, order[0])
self.tw_order.setItem(self.tw_order.rowCount()-1, 2, table_item)
table_item = QTableWidgetItem(order[4].strftime("%d.%m.%Y"))
table_item.setData(-1, order[0])
self.tw_order.setItem(self.tw_order.rowCount()-1, 3, table_item)
table_item = QTableWidgetItem(str(order[5]))
table_item.setData(-1, order[0])
self.tw_order.setItem(self.tw_order.rowCount()-1, 4, table_item)
def addImage(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Images", '',
"Images (*.png *.xpm *.jpg);;All Files (*)")
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
imageName = QFileInfo(fileName).baseName()
item0 = QTableWidgetItem(imageName)
item0.setData(Qt.UserRole, fileName)
item0.setFlags(item0.flags() & ~Qt.ItemIsEditable)
item1 = QTableWidgetItem("Normal")
item2 = QTableWidgetItem("Off")
if self.guessModeStateAct.isChecked():
if '_act' in fileName:
item1.setText("Active")
elif '_dis' in fileName:
item1.setText("Disabled")
elif '_sel' in fileName:
item1.setText("Selected")
if '_on' in fileName:
item2.setText("On")
self.imagesTable.setItem(row, 0, item0)
self.imagesTable.setItem(row, 1, item1)
self.imagesTable.setItem(row, 2, item2)
self.imagesTable.openPersistentEditor(item1)
self.imagesTable.openPersistentEditor(item2)
item0.setCheckState(Qt.Checked)
def ui_calc(self):
query = """SELECT pack.Cut_Id, pack.Number, CONCAT(product_article.Article, ' (', product_article_size.Size, ') [', product_article_parametrs.Name, ']'),
clients.Name, pack.Date_Make
FROM pack LEFT JOIN clients ON pack.Client_Id = clients.Id
LEFT JOIN product_article_parametrs ON pack.Article_Parametr_Id = product_article_parametrs.Id
LEFT JOIN product_article_size ON product_article_parametrs.Product_Article_Size_Id = product_article_size.Id
LEFT JOIN product_article ON product_article_size.Article_Id = product_article.Id
WHERE pack.Date_Make >= %s AND pack.Date_Make <= %s"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toString(Qt.ISODate), self.de_date_to.date().toString(Qt.ISODate)))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения принятых пачек", sql_info.msg, QMessageBox.Ok)
return False
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
if not sql_info:
return False
for table_typle in sql_info:
self.tableWidget.insertRow(self.tableWidget.rowCount())
for column in range(len(table_typle)):
if isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
item.setData(5, table_typle[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, column , item)
def updateDeviceTable(self, device, isNew):
if (isNew):
self.tables[TID_D].insertRow(0)
# "Name" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(device.name)
item.setData(5, device.xmlId)
self.tables[TID_D].setItem(0, 0, item)
# "Bluetooth Address" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(device.hwId)
self.tables[TID_D].setItem(0, 1, item)
# "Type" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(DEVICE_TYPES[device.devType])
self.tables[TID_D].setItem(0, 2, item)
else:
items = self.tables[TID_D].selectedItems()
items[0].setText(device.name)
items[2].setText(device.hwId)
items[2].setText(DEVICE_TYPES[device.devType])
def set_table_info(self):
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
if not self.table_items:
return False
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
for column in range(1, len(table_typle)):
if isinstance(table_typle[column], Decimal):
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(table_typle[column]))
elif isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
if column == 8:
if table_typle[0] in self.other_value:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setData(5, table_typle[0])
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 1, item)
def set_table_info(self):
self.table_widget.setSortingEnabled(False)
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
if not self.table_items:
return False
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
for column in range(2, len(table_typle)):
item = QTableWidgetItem(str(table_typle[column]))
item.setData(5, table_typle[0])
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 2, item)
self.table_widget.setSortingEnabled(True)
try:
item = self.tree_widget.currentItem()
if item.data(0, 5) >= 0: # Проверка не выбрано ли показать все!
self.ui_sorting(item)
except:
pass
if self.select_item:
self.open_id(self.select_item)
self.select_item = None
def add_song(self, song_title, song_artist, song_path):
title = QTableWidgetItem(song_title)
title.setData(Qt.UserRole, song_path)
title.setSizeHint(QSize(0, 30))
artist = QTableWidgetItem(song_artist)
row = self.ui.fileWidget.rowCount()
self.ui.fileWidget.insertRow(row)
self.ui.fileWidget.setItem(row, 0, title)
self.ui.fileWidget.setItem(row, 1, artist)
class GalleryDownloaderItem(QObject):
"""
Receives a HenItem
"""
d_item_ready = pyqtSignal(object)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.d_item_ready.connect(self.done)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setData(Qt.UserRole+1, hitem)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('In queue...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
self.status_timer = QTimer()
self.status_timer.timeout.connect(self.check_progress)
self.status_timer.start(500)
def check_progress(self):
if self.item.current_state == self.item.DOWNLOADING:
btomb = 1048576
self.status_item.setText("{0:.2f}/{1:.2f} MB".format(self.item.current_size/btomb,
self.item.total_size/btomb))
self.size_item.setText("{0:.2f} MB".format(self.item.total_size/btomb))
elif self.item.current_state == self.item.CANCELLED:
self.status_item.setText("Cancelled!")
self.status_timer.stop()
def done(self):
self.status_timer.stop()
if self.item.download_type == 0:
self.status_item.setText("Sent to library!")
else:
self.status_item.setText("Sent to torrent client!")
def add_adress(self):
adress = ClientAdress()
if adress.exec() == 0:
return False
row = self.tw_adres.rowCount()
self.tw_adres.insertRow(row)
table_item = QTableWidgetItem(adress.le_name.text())
table_item.setData(-2, "new")
self.tw_adres.setItem(row, 0, table_item)
table_item = QTableWidgetItem(adress.le_adres.text())
self.tw_adres.setItem(row, 1, table_item)
table_item = QTableWidgetItem(adress.le_kpp.text())
self.tw_adres.setItem(row, 2, table_item)
def table_sort(self):
date = QDate.currentDate()
for i in range(0, 50, 5):
self.tw_sort.insertRow(self.tw_sort.rowCount())
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, str(i))
self.tw_sort.setItem(self.tw_sort.rowCount() - 1, 0, item)
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, date.addDays(-i))
self.tw_sort.setItem(self.tw_sort.rowCount() - 1, 1, item)
def ui_select_position(self):
query = """SELECT Id, Class, Atr1, Atr2, Atr_Value FROM access WHERE Staff_Position_Id = %s ORDER BY Class"""
sql_info = my_sql.sql_select(query, (self.cb_position.currentData(),))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql при получении доступов", sql_info.msg, QMessageBox.Ok)
return False
self.worker = None
self.position = self.cb_position.currentData()
self.tw_access.clearContents()
self.tw_access.setRowCount(0)
for row, item in enumerate(sql_info):
self.tw_access.insertRow(row)
new_table_item = QTableWidgetItem(str(item[1]))
new_table_item.setData(-2, item[0])
self.tw_access.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(item[2]))
new_table_item.setData(-2, item[0])
self.tw_access.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(item[3]))
new_table_item.setData(-2, item[0])
self.tw_access.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(item[4]))
new_table_item.setData(-2, item[0])
self.tw_access.setItem(row, 3, new_table_item)
def add_uav_to_dashboard(self, uav_id):
#add table row
self.__ui.tbl_uav_list.insertRow(self.__ui.tbl_uav_list.rowCount())
next_item = QTableWidgetItem()
#sort ID column numerically, not lexicographically:
next_item.setData(Qt.DisplayRole, uav_id)
self.__ui.tbl_uav_list.setItem(
self.__ui.tbl_uav_list.rowCount() - 1, self.__ID_COL, next_item)
#this row has never been updated
self.__uav_update_map[uav_id] = 0.0
self.__uav_row_map[uav_id] = self.__ui.tbl_uav_list.rowCount()-1
self.init_row(uav_id)
def drawFieldsTable(self): # Draws the fields table on startup and redraws it when changed
fields = self.fields
self.fieldsTable.setRowCount(0)
for i in range(len(fields)):
self.fieldsTable.setRowCount(i+1)
item = QTableWidgetItem(fields[i].name())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, i) # set field index
self.fieldsTable.setItem(i,0,item)
item = QTableWidgetItem(fields[i].typeName())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.fieldsTable.setItem(i,1,item)
self.fieldsTable.setColumnWidth(0, 128)
self.fieldsTable.setColumnWidth(1, 64)
def add_number(self):
number = ClientNumber()
number.de_date_from.setDate(QDate.currentDate())
if number.exec() == 0:
return False
row = self.tw_vendor_number.rowCount()
self.tw_vendor_number.insertRow(row)
table_item = QTableWidgetItem(number.le_vendor.text())
table_item.setData(-2, "new")
self.tw_vendor_number.setItem(row, 0, table_item)
table_item = QTableWidgetItem(number.le_contract.text())
self.tw_vendor_number.setItem(row, 1, table_item)
table_item = QTableWidgetItem(number.de_date_from.date().toString("dd.MM.yyyy"))
self.tw_vendor_number.setItem(row, 2, table_item)
def set_table_road(self):
date_old = self.de_road_date.date()
date_old = datetime.date(date_old.year(), date_old.month(), date_old.day())
query = """SELECT One_year, Many_year FROM program_settings_road"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение цен оплаты проезда", sql_info.msg, QMessageBox.Ok)
return False
self.one_year_price = sql_info[0][0]
self.many_year_price = sql_info[0][1]
query = """SELECT Id, First_Name, Last_Name, Date_Recruitment
FROM staff_worker_info
WHERE Date_Recruitment < %s AND `Leave` = 0"""
sql_info = my_sql.sql_select(query, (date_old.replace(date_old.year-1), ))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение сотрудников со стажем", sql_info.msg, QMessageBox.Ok)
return False
self.tw_road.clearContents()
self.tw_road.setRowCount(0)
for row, worker in enumerate(sql_info):
self.tw_road.insertRow(row)
delta_date = date_old - worker[3]
if delta_date.days < 730:
color = QBrush(QColor(252, 252, 139, 255))
price = self.one_year_price
else:
color = QBrush(QColor(252, 190, 139, 255))
price = self.many_year_price
new_table_item = QTableWidgetItem(str(worker[2]) + " " + str(worker[1]))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(worker[3].strftime("%d.%m.%Y"))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(delta_date.days))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(price))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
self.tw_road.setItem(row, 3, new_table_item)
def ui_calc(self):
query = """SELECT staff_worker_info.Id, staff_worker_info.Last_Name,
min((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id))),
avg((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id))),
max((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id)))
FROM cut LEFT JOIN staff_worker_info ON cut.Worker_Id = staff_worker_info.Id
WHERE cut.Date_Cut >= %s AND cut.Date_Cut <= %s
GROUP BY cut.Worker_Id"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toString(Qt.ISODate), self.de_date_to.date().toString(Qt.ISODate)))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение значение обрези", sql_info.msg, QMessageBox.Ok)
return False
self.tw_work.clearContents()
self.tw_work.setRowCount(0)
if not sql_info:
return False
list_awg = []
for table_typle in sql_info:
self.tw_work.insertRow(self.tw_work.rowCount())
list_awg.append(table_typle[3])
for column in range(1, len(table_typle)):
if isinstance(table_typle[column], Decimal):
text = str(round(float(table_typle[column]), 4))
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
item.setData(5, table_typle[0])
self.tw_work.setItem(self.tw_work.rowCount() - 1, column - 1, item)
query = """SELECT min((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id))),
avg((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id))),
max((cut.Weight_Rest * 100) / (cut.Weight_Rest + (SELECT SUM(Weight) FROM pack WHERE pack.Cut_Id = cut.Id)))
FROM cut WHERE cut.Date_Cut >= %s AND cut.Date_Cut <= %s"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toString(Qt.ISODate), self.de_date_to.date().toString(Qt.ISODate)))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение значение обрези", sql_info.msg, QMessageBox.Ok)
return False
if not sql_info:
return False
self.le_min.setText(str(round(sql_info[0][0], 4)))
self.le_awg.setText(str(round(sql_info[0][1], 4)))
self.le_max.setText(str(round(sql_info[0][2], 4)))
def remplirTableau(self):
self.tableResultats.setRowCount(len(self.listeDonnees))
for i, dictionnaire in enumerate(self.listeDonnees):
# Creation des QTableWidgetItem
colonne = 0
for cle in self.listeCleDonnees:
if(isinstance(dictionnaire[cle], datetime.date)):
self.tableResultats.setItem(i, colonne, QTableWidgetItem((str(dictionnaire[cle]))))
elif (cle == "IdEquipement" or cle == "NumeroBonTravail"):
item = QTableWidgetItem()
item.setData(Qt.EditRole, int(dictionnaire[cle]))
self.tableResultats.setItem(i, colonne, item)
else:
self.tableResultats.setItem(i, colonne, QTableWidgetItem((dictionnaire[cle])))
colonne += 1
self.tableResultats.resizeColumnsToContents()
def peupler_tableau(self): depenses = controleur_depenses.liste_depenses() self.fenetre.ui.tabDep.setRowCount(len(depenses)) self.fenetre.ui.tabDep.setColumnCount(4) i=0 for depense in depenses: nom = QTableWidgetItem(depense.nom) nom.setData(Qt.UserRole, depense.id) self.fenetre.ui.tabDep.setItem(i,0,nom) description = QTableWidgetItem(depense.description) self.fenetre.ui.tabDep.setItem(i,1,description) montant = QTableWidgetItem(str(depense.montant)) self.fenetre.ui.tabDep.setItem(i,2,montant) categorie = QTableWidgetItem(depense.categorie.nom) self.fenetre.ui.tabDep.setItem(i,3,categorie) i+=1
def onAddValueClicked(self):
rows = self.uiValuesTable.rowCount()
self.uiValuesTable.setRowCount(rows + 1)
item = QTableWidgetItem(self.uiInputCombo.currentText())
item.setData(Qt.UserRole, self.uiInputCombo.currentData())
self.uiValuesTable.setItem(rows, 0, item)
item = QTableWidgetItem(self.uiValueEdit.text())
self.uiValuesTable.setItem(rows, 1, item)
self.uiValuesTable.setColumnWidth(0, self.uiValuesTable.width() / 3 * 2 - 1)
self.uiValuesTable.setColumnWidth(1, self.uiValuesTable.width() / 3 - 1)
self.uiOutputCombo.removeItem(self.uiInputCombo.currentIndex())
self.uiOutputCombo.setCurrentIndex(-1)
self.uiInputCombo.removeItem(self.uiInputCombo.currentIndex())
self.uiInputCombo.setCurrentIndex(-1)
self.uiRemoveValueButton.setEnabled(True)
self.uiClearValueButton.setEnabled(True)
def remplirTableau(self):
self.tableResultats.setRowCount(len(self.listeResultat))
if(any(self.listeResultat)):
for i, dictionnaire in enumerate(self.listeResultat):
# Creation des QTableWidgetItem
colonne = 0
for cle in self.listeCleDonnees:
if(cle == "Id"):
item = QTableWidgetItem()
item.setData(Qt.EditRole, int(dictionnaire[cle]))
self.tableResultats.setItem(i, colonne, item)
else:
self.tableResultats.setItem(i, colonne, QTableWidgetItem(str(dictionnaire[cle])))
colonne += 1
self.tableResultats.resizeColumnsToContents()
else:
self.chargement.aucunResultat.emit()
def double_click_adress(self, select_items):
row = select_items
select_adres = (self.tw_adres.item(row, 0).data(-1), self.tw_adres.item(row, 0).text(), self.tw_adres.item(row, 1).text(), self.tw_adres.item(row, 2).text())
adress = ClientAdress()
adress.le_name.setText(select_adres[1])
adress.le_adres.setText(select_adres[2])
adress.le_kpp.setText(select_adres[3])
if adress.exec() == 0:
return False
sql_status = "update" if (self.tw_adres.item(row, 0).data(-2) != "new") else "new"
table_item = QTableWidgetItem(adress.le_name.text())
table_item.setData(-1, select_adres[0])
table_item.setData(-2, sql_status)
self.tw_adres.setItem(row, 0, table_item)
table_item = QTableWidgetItem(adress.le_adres.text())
self.tw_adres.setItem(row, 1, table_item)
table_item = QTableWidgetItem(adress.le_kpp.text())
self.tw_adres.setItem(row, 2, table_item)
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in range(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setData(Qt.UserRole, row)
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled |
Qt.ItemIsUserCheckable)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def populateTableWidget(tableWidget):
staticData = (
("Mass in B-Minor", "Baroque", "J.S. Bach", 5),
("Three More Foxes", "Jazz", "Maynard Ferguson", 4),
("Sex Bomb", "Pop", "Tom Jones", 3),
("Barbie Girl", "Pop", "Aqua", 5),
)
for row, (title, genre, artist, rating) in enumerate(staticData):
item0 = QTableWidgetItem(title)
item1 = QTableWidgetItem(genre)
item2 = QTableWidgetItem(artist)
item3 = QTableWidgetItem()
item3.setData(0, StarRating(rating))
tableWidget.setItem(row, 0, item0)
tableWidget.setItem(row, 1, item1)
tableWidget.setItem(row, 2, item2)
tableWidget.setItem(row, 3, item3)
def add_item_from_model(self, music_model, tracks_type):
artist_name = ''
music_item = QTableWidgetItem(music_model['name'])
album_item = QTableWidgetItem(music_model['album']['name'])
if len(music_model['artists']) > 0:
artist_name = music_model['artists'][0]['name']
artist_item = QTableWidgetItem(artist_name)
duration = music_model['duration']
m = int(duration / 60000)
s = int((duration % 60000) / 1000)
duration = str(m) + ':' + str(s)
duration_item = QTableWidgetItem(duration)
music_item.setData(Qt.UserRole, music_model)
row = self.rowCount()
self.setRowCount(row + 1)
self.setItem(row, 1, music_item)
self.setItem(row, 2, artist_item)
self.setItem(row, 3, album_item)
self.setItem(row, 4, duration_item)
if self._tracks_type is not 4:
self.setColumnHidden(0, False)
if MusicModel.mv_available(music_model):
mv_label = QLabel('MV')
mv_label.setObjectName('tracks_table_mv_btn')
self.setCellWidget(row, 0, mv_label)
else:
self.setColumnHidden(0, True)
if tracks_type is 0:
btn = QLabel('✗')
btn.setObjectName('tracks_table_remove_btn')
self.setCellWidget(row, 5, btn)
self.setRowHeight(row, 35)
row_mid = dict()
row_mid['mid'] = music_model['id']
row_mid['row'] = row
return True
def ui_sorting(self, select_tree):
tree_id = select_tree.data(0, 5)
if not self.table_items:
return False
self.table_widget.setSortingEnabled(False)
if tree_id == -1:
self.set_table_info()
else:
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
for table_typle in self.table_items:
if table_typle[1] == tree_id:
self.table_widget.insertRow(self.table_widget.rowCount())
for column in range(2, len(table_typle)):
item = QTableWidgetItem(str(table_typle[column]))
item.setData(5, table_typle[0])
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 2, item)
self.table_widget.setSortingEnabled(True)
def __createItemsARow(self, rowNo, name, sex, birth, nation, isParty,
score):
"""创建行
:param rowNo: 行号
:param name: 学生名字
:param sex: 学生性别
:param birth: 出生日期
:param nation: 民族
:param isParty: 是否为党员
:param score: 得分
:return: None
"""
ID = 2018101000 + rowNo # 学号
# 姓名
item = QTableWidgetItem(name, CellType.ctName.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter) # 设置对齐方式
font = item.font() # 设置字体
font.setBold(True)
item.setFont(font)
item.setData(Qt.UserRole, ID) # 关联数据
self._ui.tableWidget.setItem(rowNo, FieldColNum.colName.value,
item) # 创建姓名单元格
# 性别
if sex == '男':
icon = QIcon(':icon/images/boy.ico') # 设置图标
else:
icon = QIcon(':icon/images/girl.ico')
item = QTableWidgetItem(sex, CellType.ctSex.value)
item.setIcon(icon)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._ui.tableWidget.setItem(rowNo, FieldColNum.colSex.value,
item) # 创建性别单元格
# 生日
strBirth = birth.toString('yyyy-MM-dd') # 将时间转换成字符串
item = QTableWidgetItem(strBirth, CellType.ctBirth.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._ui.tableWidget.setItem(rowNo, FieldColNum.colBirth.value,
item) # 创建生日单元格
# 民族
item = QTableWidgetItem(nation, CellType.ctNation.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if nation != '汉':
item.setForeground(QBrush(Qt.blue))
self._ui.tableWidget.setItem(rowNo, FieldColNum.colNation.value,
item) # 创建民族单元格
# 得分
item = QTableWidgetItem(str(score), CellType.ctScore.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._ui.tableWidget.setItem(rowNo, FieldColNum.colScore.value,
item) # 创建得分单元格
# 是否是党员
item = QTableWidgetItem('党员', CellType.ctPartyM.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if isParty:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable)
item.setBackground(QBrush(Qt.yellow))
self._ui.tableWidget.setItem(rowNo, FieldColNum.colPartM.value,
item) # 创建是否是党员单元格
def FillLocations(self, callingWidget):
species = self.lblCommonName.text()
currentItem = callingWidget.currentItem()
filter = code_Filter.Filter()
filter.setSpeciesName(species)
if callingWidget.objectName() == "trDates":
locationWidget = self.tblYearLocations
# check if currentItem is a year
if currentItem.parent() is None:
filter.setStartDate(currentItem.text(0) + "-01-01")
filter.setEndDate(currentItem.text(0) + "-12-31")
# check if currentItem is a month
elif currentItem.parent().parent() is None:
month = currentItem.text(0)
monthNumberString = self.mdiParent.db.monthNumberDict[month]
lastDayOfThisMonth = self.mdiParent.db.GetLastDayOfMonth(
monthNumberString)
year = currentItem.parent().text(0)
filter.setStartDate(year + "-" + monthNumberString + "-01")
filter.setEndDate(year + "-" + monthNumberString + "-" +
lastDayOfThisMonth)
# item is a just a single date
else:
filter.setStartDate(currentItem.text(0))
filter.setEndDate(currentItem.text(0))
if callingWidget.objectName() == "trMonthDates":
locationWidget = self.tblMonthLocations
# check if currentItem is a month
if currentItem.parent() is None:
monthNumberString = self.mdiParent.db.monthNumberDict[
currentItem.text(0)]
lastDayOfThisMonth = self.mdiParent.db.GetLastDayOfMonth(
monthNumberString)
filter.setStartSeasonalMonth(monthNumberString)
filter.setStartSeasonalDay("01")
filter.setEndSeasonalMonth(monthNumberString)
filter.setEndSeasonalDay(lastDayOfThisMonth)
# check if currentItem is a year
elif currentItem.parent().parent() is None:
year = currentItem.text(0)
monthString = currentItem.parent().text(0)
monthNumberString = self.mdiParent.db.monthNumberDict[
monthString]
filter.setStartDate(year + "-" + monthNumberString + "-01")
filter.setEndDate(year + "-" + monthNumberString + "-31")
# item is a just a single date
else:
filter.setStartDate(currentItem.text(0))
filter.setEndDate(currentItem.text(0))
locations = self.mdiParent.db.GetLocations(filter, "Checklist")
locationWidget.clear()
locationWidget.setColumnCount(2)
locationWidget.setRowCount(len(locations))
locationWidget.horizontalHeader().setVisible(False)
locationWidget.verticalHeader().setVisible(False)
header = locationWidget.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
locationWidget.setShowGrid(False)
metrics = locationWidget.fontMetrics()
textHeight = metrics.boundingRect("A").height()
R = 0
for l in locations:
locationItem = QTableWidgetItem()
locationItem.setText(l[0])
# store checklist ID in hidden data component of item
locationItem.setData(Qt.UserRole, QVariant(l[2]))
speciesCountItem = QTableWidgetItem()
speciesCountItem.setData(Qt.DisplayRole, l[1])
locationWidget.setItem(R, 0, locationItem)
locationWidget.setItem(R, 1, speciesCountItem)
locationWidget.setRowHeight(R, textHeight * 1.1)
R = R + 1
self.lblLocationsForDate.setText("Checklists (" +
str(locationWidget.rowCount()) + ")")
def refresh(self, reason=""):
if len(self.wallet.dao) == 0:
return
if not "p" in self.wallet.dao:
return
filtered = []
for p in self.wallet.dao["p"]:
p_item = self.wallet.dao["p"][p]
if p_item["state"] == self.filter():
filtered.append(p_item)
if filtered == self.list and reason != "votes":
return
self.list = filtered
self.clearContents()
self.setRowCount(len(self.list));
for i, item in enumerate(self.list):
proposal = item
hash = QTableWidgetItem()
hash.setData(Qt.DisplayRole, proposal["hash"])
self.setItem(i, FundColumns.HASH, hash);
desc = QTableWidgetItem()
desc.setData(Qt.DisplayRole, proposal["description"])
self.setItem(i, FundColumns.DESCRIPTION, desc);
yes = QTableWidgetItem()
yes.setData(Qt.DisplayRole, proposal["votesYes"])
yes.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.YES, yes);
no = QTableWidgetItem()
no.setData(Qt.DisplayRole, proposal["votesNo"])
no.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.NO, no);
abs = QTableWidgetItem()
abs.setData(Qt.DisplayRole, proposal["votesAbs"])
abs.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.ABS, abs);
cv = QTableWidgetItem()
cv.setData(Qt.DisplayRole, proposal["requestedAmount"])
cv.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.AMOUNT, cv);
st = QTableWidgetItem()
st.setData(Qt.DisplayRole, self.state_to_string(proposal["state"]))
st.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.STATE, st);
current_vote = self.parent.find_vote(proposal["hash"])
mv = QTableWidgetItem()
if current_vote == 1:
mv.setData(Qt.DisplayRole, _("Yes"))
if current_vote == 0:
mv.setData(Qt.DisplayRole, _("No"))
if current_vote == -1:
mv.setData(Qt.DisplayRole, _("Abstain"))
if current_vote == None:
mv.setData(Qt.DisplayRole, _("None"))
mv.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(i, FundColumns.MYVOTE, mv);
def getTableItem(self, v, p):
item = QTableWidgetItem(v)
if p != 0: # Common priority uses default label color.
item.setForeground(self.color)
item.setData(Qt.UserRole, p)
return item
def FillLocationTotals(self, filter):
self.filter = deepcopy(filter)
# find all years, months, and dates in db
dbCountries = set()
dbStates = set()
dbCounties = set()
dbLocations = set()
countryDict = defaultdict()
stateDict = defaultdict()
countyDict = defaultdict()
locationDict = defaultdict()
minimalSightingList = self.mdiParent.db.GetMinimalFilteredSightingsList(filter)
for s in minimalSightingList:
# Consider only full species, not slash or spuh entries
commonName = s["commonName"]
if ("/" not in commonName) and ("sp." not in commonName):
if self.mdiParent.db.TestSighting(s, filter) is True:
dbCountries.add(s["country"])
dbStates.add(s["state"])
if s["county"] != "":
dbCounties.add(s["county"])
dbLocations.add(s["location"])
# create dictionaries of country, state, county, and location sighting for faster lookup
if s["country"] not in countryDict.keys():
countryDict[s["country"]] = [s]
else:
countryDict[s["country"]].append(s)
if s["state"] not in stateDict.keys():
stateDict[s["state"]] = [s]
else:
stateDict[s["state"]].append(s)
if s["county"] != "":
if s["county"] not in countyDict.keys():
countyDict[s["county"]] = [s]
else:
countyDict[s["county"]].append(s)
if s["location"] not in locationDict.keys():
locationDict[s["location"]] = [s]
else:
locationDict[s["location"]].append(s)
# check if no sightings were found. Return false if none found. Abort and display message.
if len(countryDict) + len(stateDict) + len(countyDict) + len(locationDict) == 0:
return(False)
# set numbers of rows for each tab's grid (years, months, dates)
self.tblCountryTotals.setRowCount(len(dbCountries))
self.tblCountryTotals.setColumnCount(4)
self.tblStateTotals.setRowCount(len(dbStates))
self.tblStateTotals.setColumnCount(4)
self.tblCountyTotals.setRowCount(len(dbCounties))
self.tblCountyTotals.setColumnCount(4)
self.tblLocationTotals.setRowCount(len(dbLocations))
self.tblLocationTotals.setColumnCount(4)
self.tblCountryTotals.setShowGrid(False)
self.tblStateTotals.setShowGrid(False)
self.tblCountyTotals.setShowGrid(False)
self.tblLocationTotals.setShowGrid(False)
countryArray = []
for country in dbCountries:
countrySpecies = set()
countryChecklists = set()
for s in countryDict[country]:
countrySpecies.add(s["commonName"])
countryChecklists.add(s["checklistID"])
countryArray.append([len(countrySpecies), country, len(countryChecklists)])
countryArray.sort(reverse=True)
R = 0
for country in countryArray:
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, R+1)
countryItem = QTableWidgetItem()
countryItem.setText(self.mdiParent.db.GetCountryName(country[1]))
countryTotalItem = QTableWidgetItem()
countryTotalItem.setData(Qt.DisplayRole, country[0])
countryTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
countryChecklistTotalItem = QTableWidgetItem()
countryChecklistTotalItem.setData(Qt.DisplayRole, country[2])
countryChecklistTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
self.tblCountryTotals.setItem(R, 0, rankItem)
self.tblCountryTotals.setItem(R, 1, countryItem)
self.tblCountryTotals.setItem(R, 2, countryTotalItem)
self.tblCountryTotals.setItem(R, 3, countryChecklistTotalItem)
R = R + 1
stateArray = []
for state in dbStates:
stateSpecies = set()
stateChecklists = set()
for s in stateDict[state]:
stateSpecies.add(s["commonName"])
stateChecklists.add(s["checklistID"])
stateArray.append([len(stateSpecies), state, len(stateChecklists)])
stateArray.sort(reverse=True)
R = 0
for state in stateArray:
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, R+1)
stateItem = QTableWidgetItem()
stateItem.setText(self.mdiParent.db.GetStateName(state[1]))
stateTotalItem = QTableWidgetItem()
stateTotalItem.setData(Qt.DisplayRole, state[0])
stateTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
stateChecklistTotalItem = QTableWidgetItem()
stateChecklistTotalItem.setData(Qt.DisplayRole, state[2])
stateChecklistTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
self.tblStateTotals.setItem(R, 0, rankItem)
self.tblStateTotals.setItem(R, 1, stateItem)
self.tblStateTotals.setItem(R, 2, stateTotalItem)
self.tblStateTotals.setItem(R, 3, stateChecklistTotalItem)
R = R + 1
countyArray = []
for county in dbCounties:
if county != "" and county is not None:
countySpecies = set()
countyChecklists = set()
for s in countyDict[county]:
countySpecies.add(s["commonName"])
countyChecklists.add(s["checklistID"])
countyArray.append([len(countySpecies), county, len(countyChecklists)])
countyArray.sort(reverse=True)
R = 0
for county in countyArray:
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, R+1)
countyItem = QTableWidgetItem()
countyItem.setText(county[1])
countyTotalItem = QTableWidgetItem()
countyTotalItem.setData(Qt.DisplayRole, county[0])
countyTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
countyChecklistTotalItem = QTableWidgetItem()
countyChecklistTotalItem.setData(Qt.DisplayRole, county[2])
countyChecklistTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
self.tblCountyTotals.setItem(R, 0, rankItem)
self.tblCountyTotals.setItem(R, 1, countyItem)
self.tblCountyTotals.setItem(R, 2, countyTotalItem)
self.tblCountyTotals.setItem(R, 3, countyChecklistTotalItem)
R = R + 1
locationArray = []
for location in dbLocations:
if location != "":
locationSpecies = set()
locationChecklists = set()
for s in locationDict[location]:
locationSpecies.add(s["commonName"])
locationChecklists.add(s["checklistID"])
locationArray.append([len(locationSpecies), location, len(locationChecklists)])
locationArray.sort(reverse=True)
rank = 0
lastLocationTotal = 0
R = 0
for location in locationArray:
rankItem = QTableWidgetItem()
if location[0] != lastLocationTotal:
rank = R+1
rankItem.setData(Qt.DisplayRole, rank)
locationItem = QTableWidgetItem()
locationItem.setText(location[1])
locationTotalItem = QTableWidgetItem()
locationTotalItem.setData(Qt.DisplayRole, location[0])
locationTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
locationChecklistTotalItem = QTableWidgetItem()
locationChecklistTotalItem.setData(Qt.DisplayRole, location[2])
locationChecklistTotalItem.setTextAlignment(Qt.AlignCenter|Qt.AlignVCenter)
self.tblLocationTotals.setItem(R, 0, rankItem)
self.tblLocationTotals.setItem(R, 1, locationItem)
self.tblLocationTotals.setItem(R, 2, locationTotalItem)
self.tblLocationTotals.setItem(R, 3, locationChecklistTotalItem)
lastLocationTotal = location[0]
R = R + 1
# set headers and column stretching
for t in [self.tblCountryTotals, self.tblStateTotals, self.tblCountyTotals, self.tblLocationTotals]:
t.setSortingEnabled(True)
t.sortItems(0,0)
t.horizontalHeader().setVisible(True)
# remove first three characters from tbl widget name
regionType = t.objectName()[3:]
# remove "Totals" from widget name
regionType = regionType[:-6]
t.setHorizontalHeaderLabels(['Rank', regionType, 'Species', 'Checklists'])
header = t.horizontalHeader()
header.setSectionResizeMode(1, QHeaderView.Stretch)
# set location and date range titles
self.mdiParent.SetChildDetailsLabels(self, self.filter)
# set window title
self.setWindowTitle("Location Totals: " + self.lblLocation.text() + ": " + self.lblDateRange.text())
if self.lblDetails.text() != "":
self.lblDetails.setVisible(True)
else:
self.lblDetails.setVisible(False)
self.scaleMe()
self.resizeMe()
return(True)
if pixmap.isNull():
continue
pixmap = pixmap.scaled(ICON_WIDTH, ICON_WIDTH, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
base_file_name = Path(file_name).name
item = QListWidgetItem(QIcon(pixmap), base_file_name)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setSizeHint(QSize(ICON_WIDTH, ICON_HEIGHT + 20))
list_widget.addItem(item)
table_widget.setRowCount(table_widget.rowCount() + 1)
table_widget.setRowHeight(row, ICON_HEIGHT)
item_img = QTableWidgetItem()
item_img.setData(Qt.DecorationRole, pixmap)
item_img.setSizeHint(QSize(ICON_WIDTH, ICON_HEIGHT))
table_widget.setItem(row, 0, item_img)
table_widget.setItem(row, 1, QTableWidgetItem(base_file_name))
table_widget.setItem(row, 2,
QTableWidgetItem(str(Path(file_name).parent)))
row += 1
QApplication.processEvents()
list_widget.setWindowTitle(list_widget.windowTitle() + '. Elapsed: ' +
str(DT.datetime.now() -
start_time).split('.')[0])
table_widget.setWindowTitle(table_widget.windowTitle() + '. Elapsed: ' +
str(DT.datetime.now() -
start_time).split('.')[0])
def update_schedule(self) -> None:
self.clearSpans()
self.clearContents()
rows = self._schedule_ref.rows()
columns = self._schedule_ref.columns()
self.setRowCount(rows)
self.setColumnCount(columns)
i = 0
for day_number, schedule_element in enumerate(self._schedule_ref):
min_i = i
for line in schedule_element:
j = 0
while j < columns:
text = ""
duration = 1
pairs = line.get(j)
if pairs is not None:
duration = pairs[0]["time"].duration()
for pair in pairs:
text += str(pair) + "\n"
item = QTableWidgetItem(text)
item.setTextAlignment(Qt.AlignTop | Qt.AlignLeft)
item.setData(Qt.UserRole, duration)
self.setItem(i, j, item)
j += duration
i += 1
for n in range(columns):
for m in range(i - 1, min_i - 1, -1):
item = self.item(m, n)
if item is not None:
up_level, down_level = m, m
duration = item.data(Qt.UserRole)
# down
for p in range(m + 1, i):
free = True
for r in range(duration):
cmp_item = self.item(p, n + r)
if cmp_item is None or cmp_item.text() != "":
free = False
break
if free:
down_level = p
for r in range(duration):
self.takeItem(p, n + r)
else:
break
# up
for p in range(m - 1, min_i - 1, -1):
free = True
for r in range(duration):
cmp_item = self.item(p, n + r)
if cmp_item is None or cmp_item.text() != "":
free = False
break
if free:
up_level = p
for r in range(duration):
self.takeItem(p, n + r)
else:
break
if (abs(up_level - down_level) +
1) > 1 or duration > 1:
if self.columnSpan(up_level, n) == 1 or \
self.rowSpan(up_level, n) == 1:
self.setItem(up_level, n, self.takeItem(m, n))
self.setSpan(up_level, n,
abs(up_level - down_level) + 1,
duration)
self.resize_table()
def on_btnBrowse_clicked(self, checked, directoryPath=None, secType=None):
"""
Selects base spectra
:param directoryPath: optional path input
:param secType: optional secondary spectrum type
"""
self.dir = dir = directoryPath
if self.dir is None:
options = QFileDialog.ShowDirsOnly
if sys.platform.startswith('win'):
options = QFileDialog.DontUseNativeDialog
self.dir = dir = QFileDialog.getExistingDirectory(
self, 'Choose Base Spectra Directory',
self.settings.getDataDirectory(), options)
if dir:
self.txtFilepath.setText(dir)
self.tblSpectra.clearContents()
filenames = [
f for f in os.listdir(dir) if f.lower().endswith(".n42")
]
if not filenames:
QMessageBox.critical(self, 'Invalid Directory Selection',
'No n42 Files in selected Directory')
return
#read the spectra into memory
try:
self.specMap = {}
for filename in filenames:
v = readSpectrumFile(dir + os.sep + filename,
self.sharedObject, self.txtStatus)
if v:
self.specMap[filename] = ReadFileObject(
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7],
v[8], v[9])
# get ecal, counts, and bckg spetrum parameters for one spectrum
for filename in self.specMap.keys():
rfo = self.specMap[filename]
self.counts = rfo.counts
self.ecal = rfo.ecal
self.countsBckg = rfo.countsBckg
self.ecalBckg = rfo.ecalBckg
break
# make sure ecal, # of channels, and bckg spetrum parameters match for all spectra
for filename in self.specMap.keys():
rfo = self.specMap[filename]
if self.counts.count(',') != rfo.counts.count(','):
self.txtStatus.append(
"Mismatch in # of channels between spectra")
self.txtStatus.setTextColor(self.redColor)
for i in range(len(self.ecal)):
if self.ecal[i] != rfo.ecal[i]:
self.txtStatus.append(
"Mismatch in " + str(i) +
"th energy calibration parameter between spectra"
)
self.txtStatus.setTextColor(self.blackColor)
if self.countsBckg:
if self.countsBckg.count(',') != rfo.countsBckg.count(
','):
self.txtStatus.append(
"Mismatch in # of channels between background spectra"
)
for i in range(len(self.ecal)):
if self.ecalBckg[i] != rfo.ecalBckg[i]:
self.txtStatus.append(
"Mismatch in " + str(i) +
"th energy calibration parameter between background spectra"
)
except Exception as e:
traceback.print_exc()
logging.exception("Handled Exception", exc_info=True)
# populate material, filename table
self.initializingTable = True
spectraCounter = 0
for filename in self.specMap.keys():
#if readSpectrumFile(dir + os.sep + filename, self.sharedObject, self.txtStatus):
spectraCounter = spectraCounter + 1
# TODO: develop more elaborated algorithm to correctly import thing like "HEU" or "WGPu" w/o altering the capitalization
# matName = '-'.join(splitext(filename)[0].split('_')[2:]).capitalize()
matName = '-'.join(splitext(filename)[0].split('_')[2:])
matTranslation = Session().query(MaterialNameTranslation).get(
matName)
toName = matTranslation.toName if matTranslation else matName
row = self.tblSpectra.rowCount()
self.tblSpectra.setRowCount(row + 1)
# material name
item = QTableWidgetItem(toName)
item.setData(Qt.UserRole, matName)
self.tblSpectra.setItem(row, 0, item)
# filename
item = QTableWidgetItem(filename)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.tblSpectra.setItem(row, 1, item)
self.txtStatus.append("Number of base spectra read = " +
str(spectraCounter))
if self.sharedObject:
if self.sharedObject.chanDataType:
self.txtStatus.append("Channel data type is " +
self.sharedObject.chanDataType)
if self.sharedObject.bkgndSpectrumInFile:
self.txtStatus.append("Secondary spectrum found in file")
self.initializingTable = False
self.tblSpectra.resizeColumnsToContents()
self.tblSpectra.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
# Check with the user about the type of the secondary spectrum
if self.sharedObject.bkgndSpectrumInFile:
secondary_types = [
"Background Spectrum", "Internal Calibration Spectrum"
]
if secType is None:
s_type, ok = QInputDialog.getItem(
self, "Select Secondary Spectrum Type",
"Secondary Spectrum was found. <br> "
"Select type or press cancel to disable secondary spectrum:",
secondary_types, 0, False)
if ok:
self.backgroundSpectrumType = secondary_types.index(
s_type)
self.txtStatus.append(
"Secondary spectrum identified as " + s_type)
else:
self.txtStatus.append(
"Secondary spectrum not included")
else:
self.backgroundSpectrumType = secondary_types.index(
secType)
self.txtStatus.append("Secondary spectrum identified as " +
secType)
def FillLocations(self, filter):
self.filter = filter
self.listType = "Locations"
self.btnShowLocation.setVisible(False)
self.lblDetails.setVisible(False)
# set up tblList column headers and widths
self.tblList.setShowGrid(False)
header = self.tblList.horizontalHeader()
header.setVisible(True)
thisWindowList = self.mdiParent.db.GetLocations(filter, "Dates")
if len(thisWindowList) == 0:
return (False)
# set 3 columns and header titles
self.tblList.setRowCount(len(thisWindowList))
self.tblList.setColumnCount(3)
self.tblList.setHorizontalHeaderLabels(['Location', 'First', 'Last'])
header.setSectionResizeMode(0, QHeaderView.Stretch)
# add locations and dates to table row by row
R = 0
for loc in thisWindowList:
locationItem = QTableWidgetItem()
locationItem.setText(loc[0])
firstItem = QTableWidgetItem()
firstItem.setData(Qt.DisplayRole, loc[1])
lastItem = QTableWidgetItem()
lastItem.setData(Qt.DisplayRole, loc[2])
self.tblList.setItem(R, 0, locationItem)
self.tblList.setItem(R, 1, firstItem)
self.tblList.setItem(R, 2, lastItem)
R = R + 1
# hide the checklist comments box, since we're not showing a single checklist
self.txtChecklistComments.setVisible(False)
# hide the checklist details label, since we're not showing a single checklist
self.lblDetails.setText("")
locationCount = self.tblList.rowCount()
self.lblSpecies.setText("Locations: " + str(locationCount))
self.mdiParent.SetChildDetailsLabels(self, filter)
self.setWindowTitle(self.lblLocation.text() + ": " +
self.lblDateRange.text())
icon = QIcon()
icon.addPixmap(QPixmap(":/icon_location.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.tblList.addAction(self.actionSetLocationFilter)
self.tblList.addAction(self.actionSetFirstDateFilter)
self.tblList.addAction(self.actionSetLastDateFilter)
self.scaleMe()
self.resizeMe()
return (True)
def FillChecklists(self, filter):
self.filter = filter
self.listType = "Checklists"
# get species data from db
checklists = self.mdiParent.db.GetChecklists(filter)
# abort if no checklists matched filter
if len(checklists) == 0:
return (False)
# set up tblList column headers and widths
self.tblList.setColumnCount(7)
self.tblList.setRowCount(len(checklists))
self.tblList.horizontalHeader().setVisible(True)
self.tblList.setHorizontalHeaderLabels([
'Country', 'State', 'County', 'Location', 'Date', 'Time', 'Species'
])
header = self.tblList.horizontalHeader()
header.setSectionResizeMode(3, QHeaderView.Stretch)
self.tblList.setShowGrid(False)
# add species and dates to table row by row
R = 0
for c in checklists:
countryItem = QTableWidgetItem()
countryItem.setData(Qt.UserRole, QVariant(
c[0])) #store checklistID for future retreaval
countryName = self.mdiParent.db.GetCountryName(c[1][0:2])
countryItem.setText(countryName)
stateItem = QTableWidgetItem()
stateName = self.mdiParent.db.GetStateName(c[1])
stateItem.setText(stateName)
countyItem = QTableWidgetItem()
countyItem.setText(c[2])
locationItem = QTableWidgetItem()
locationItem.setText(c[3])
dateItem = QTableWidgetItem()
dateItem.setText(c[4])
timeItem = QTableWidgetItem()
timeItem.setText(c[5])
speciesCountItem = QTableWidgetItem()
speciesCountItem.setData(Qt.DisplayRole, c[6])
speciesCountItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.tblList.setItem(R, 0, countryItem)
self.tblList.setItem(R, 1, stateItem)
self.tblList.setItem(R, 2, countyItem)
self.tblList.setItem(R, 3, locationItem)
self.tblList.setItem(R, 4, dateItem)
self.tblList.setItem(R, 5, timeItem)
self.tblList.setItem(R, 6, speciesCountItem)
R = R + 1
self.lblSpecies.setText("Checklists: " + str(self.tblList.rowCount()))
self.mdiParent.SetChildDetailsLabels(self, filter)
self.setWindowTitle(self.lblLocation.text() + ": " +
self.lblDateRange.text())
self.txtChecklistComments.setVisible(False)
icon = QIcon()
icon.addPixmap(QPixmap(":/icon_checklists.png"), QIcon.Normal,
QIcon.Off)
self.setWindowIcon(icon)
self.tblList.addAction(self.actionSetDateFilter)
self.tblList.addAction(self.actionSetCountryFilter)
self.tblList.addAction(self.actionSetStateFilter)
self.tblList.addAction(self.actionSetCountyFilter)
self.tblList.addAction(self.actionSetLocationFilter)
self.scaleMe()
self.resizeMe()
# alert MainWindow that we finished fill data successfully
return (True)
def onProcMgrUpdated(self, ldProcStatus, ldOutputFileStatus, iExperiment,
sExpType):
self.statusbar.showMessage("Refreshing ProcMgr status...")
self.tableProcStat.clear()
self.tableProcStat.setSortingEnabled(False)
self.tableProcStat.setRowCount(len(ldProcStatus))
self.tableProcStat.setColumnCount(2)
self.tableProcStat.setHorizontalHeaderLabels(["ID", "Status"])
itemCur = None
for iRow, dProcStatus in enumerate(ldProcStatus):
# col 1 : UniqueID
if isinstance(dProcStatus["showId"], str):
# str
showId = dProcStatus["showId"]
else:
# bytes
showId = dProcStatus["showId"].decode()
item = QTableWidgetItem(showId)
item.setData(Qt.UserRole, QVariant(showId))
self.tableProcStat.setItem(iRow, 0, item)
if showId == self.sCurKey:
itemCur = item
# col 2 : Status
sStatus = dProcStatus["status"]
item = QTableWidgetItem()
brush1 = QBrush(QColor.fromRgb(255, 255, 255))
item.setForeground(brush1)
if (sStatus == ProcMgr.STATUS_NOCONNECT):
item.setData(0, QVariant(" NO CONNECT"))
item.setBackground(QBrush(QColor.fromRgb(0, 0, 192)))
elif (sStatus == ProcMgr.STATUS_RUNNING):
item.setData(0, QVariant("RUNNING"))
item.setBackground(QBrush(QColor.fromRgb(0, 192, 0)))
elif (sStatus == ProcMgr.STATUS_SHUTDOWN):
item.setData(0, QVariant(" SHUTDOWN"))
item.setBackground(QBrush(QColor.fromRgb(192, 192, 0)))
elif (sStatus == ProcMgr.STATUS_ERROR):
item.setData(0, QVariant(" ERROR"))
item.setBackground(QBrush(QColor.fromRgb(255, 0, 0)))
self.tableProcStat.setItem(iRow, 1, item)
# end for iRow, key in enumerate( sorted(procMgr.d.iterkeys()) ):
self.tableProcStat.setColumnWidth(0, 160)
self.tableProcStat.setColumnWidth(1, 100)
if not self.bFirstSort:
self.bFirstSort = True
self.tableProcStat.sortItems(1, Qt.AscendingOrder)
self.tableProcStat.setSortingEnabled(True)
if itemCur != None:
self.tableProcStat.setCurrentItem(itemCur)
if ldOutputFileStatus:
sOutputStatus = ""
for dOutputFileStatus in ldOutputFileStatus:
sOutputStatus += """
<p><b>Filename:</b
> %s <br>
<b>Size:</b> %s Bytes <br>
<b>Last Modification Time:</b> %s
""" % (dOutputFileStatus["fn"], dOutputFileStatus["size"].decode(),
dOutputFileStatus["mtime"].decode())
# save the scrollar positions
hVal = self.textBrowser.horizontalScrollBar().value()
vVal = self.textBrowser.verticalScrollBar().value()
self.textBrowser.setHtml(sOutputStatus)
# restore the scrollar positions
self.textBrowser.horizontalScrollBar().setValue(hVal)
self.textBrowser.verticalScrollBar().setValue(vVal)
else:
self.textBrowser.setHtml(
"No output file is found for experiment type <b>%s</b> id <b>%d</b>"
% (sExpType, iExperiment))
self.statusbar.clearMessage()
return
def FillDateTotals(self, filter):
self.filter = filter
# find all years, months, and dates in db
dbYears = set()
dbMonths = set()
dbDates = set()
dbFilteredSightings = []
yearDict = defaultdict()
monthDict = defaultdict()
dateDict = defaultdict()
minimalSightingList = self.mdiParent.db.GetMinimalFilteredSightingsList(
filter)
for sighting in minimalSightingList:
# Consider only full species, not slash or spuh or hybrid entries
commonName = sighting["commonName"]
if ("/" not in commonName) and (
"sp." not in commonName) and " x " not in commonName:
if self.mdiParent.db.TestSighting(sighting, filter) is True:
dbYears.add(sighting["date"][0:4])
dbMonths.add(sighting["date"][5:7])
dbDates.add(sighting["date"])
dbFilteredSightings.append(sighting)
if sighting["date"][0:4] not in yearDict.keys():
yearDict[sighting["date"][0:4]] = [sighting]
else:
yearDict[sighting["date"][0:4]].append(sighting)
if sighting["date"][5:7] not in monthDict.keys():
monthDict[sighting["date"][5:7]] = [sighting]
else:
monthDict[sighting["date"][5:7]].append(sighting)
if sighting["date"] not in dateDict.keys():
dateDict[sighting["date"]] = [sighting]
else:
dateDict[sighting["date"]].append(sighting)
# check that we have at least one sighting to work with
# otherwise, abort so MainWindow can post message to user
if len(yearDict) == 0:
return (False)
# set numbers of rows for each tab's grid (years, months, dates)
self.tblYearTotals.setRowCount(len(dbYears) + 1)
self.tblYearTotals.setColumnCount(4)
self.tblMonthTotals.setRowCount(len(dbMonths) + 1)
self.tblMonthTotals.setColumnCount(4)
self.tblDateTotals.setRowCount(len(dbDates) + 1)
self.tblDateTotals.setColumnCount(4)
yearArray = []
for year in dbYears:
yearSpecies = set()
yearChecklists = set()
for s in yearDict[year]:
yearSpecies.add(s["commonName"])
yearChecklists.add(s["checklistID"])
yearArray.append([len(yearSpecies), year, len(yearChecklists)])
yearArray.sort(reverse=True)
R = 0
for year in yearArray:
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, R + 1)
yearItem = QTableWidgetItem()
yearItem.setText(year[1])
yearTotalItem = QTableWidgetItem()
yearTotalItem.setData(Qt.DisplayRole, year[0])
yearTotalItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
yearChecklistTotalItem = QTableWidgetItem()
yearChecklistTotalItem.setData(Qt.DisplayRole, year[2])
yearChecklistTotalItem.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tblYearTotals.setItem(R, 0, rankItem)
self.tblYearTotals.setItem(R, 1, yearItem)
self.tblYearTotals.setItem(R, 2, yearTotalItem)
self.tblYearTotals.setItem(R, 3, yearChecklistTotalItem)
R = R + 1
monthArray = []
for month in dbMonths:
monthSpecies = set()
monthChecklists = set()
monthChecklists.add(s["checklistID"])
for s in monthDict[month]:
monthSpecies.add(s["commonName"])
monthChecklists.add(s["checklistID"])
monthArray.append(
[len(monthSpecies), month,
len(monthChecklists) - 1])
monthArray.sort(reverse=True)
R = 0
for month in monthArray:
if month[1] == "01":
month[1] = "Jan"
if month[1] == "02":
month[1] = "Feb"
if month[1] == "03":
month[1] = "Mar"
if month[1] == "04":
month[1] = "Apr"
if month[1] == "05":
month[1] = "May"
if month[1] == "06":
month[1] = "Jun"
if month[1] == "07":
month[1] = "Jul"
if month[1] == "08":
month[1] = "Aug"
if month[1] == "09":
month[1] = "Sep"
if month[1] == "10":
month[1] = "Oct"
if month[1] == "11":
month[1] = "Nov"
if month[1] == "12":
month[1] = "Dec"
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, R + 1)
monthItem = QTableWidgetItem()
monthItem.setText(month[1])
monthTotalItem = QTableWidgetItem()
monthTotalItem.setData(Qt.DisplayRole, month[0])
monthTotalItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
monthChecklistTotalItem = QTableWidgetItem()
monthChecklistTotalItem.setData(Qt.DisplayRole, month[2])
monthChecklistTotalItem.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tblMonthTotals.setItem(R, 0, rankItem)
self.tblMonthTotals.setItem(R, 1, monthItem)
self.tblMonthTotals.setItem(R, 2, monthTotalItem)
self.tblMonthTotals.setItem(R, 3, monthChecklistTotalItem)
R = R + 1
R = -1
dateArray = []
for date in dbDates:
dateSpecies = set()
dateChecklists = set()
for s in dateDict[date]:
dateSpecies.add(s["commonName"])
dateChecklists.add(s["checklistID"])
dateArray.append([len(dateSpecies), date, len(dateChecklists)])
dateArray.sort(reverse=True)
R = 0
rank = 1
lastDateTotal = 0
for date in dateArray:
dateItem = QTableWidgetItem()
dateItem.setText(date[1][0:4] + "-" + date[1][5:7] + "-" +
date[1][8:])
dateTotalItem = QTableWidgetItem()
dateTotalItem.setData(Qt.DisplayRole, date[0])
dateTotalItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
if date[0] != lastDateTotal:
rank = R + 1
rankItem = QTableWidgetItem()
rankItem.setData(Qt.DisplayRole, rank)
dateChecklistTotalItem = QTableWidgetItem()
dateChecklistTotalItem.setData(Qt.DisplayRole, date[2])
dateChecklistTotalItem.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tblDateTotals.setItem(R, 0, rankItem)
self.tblDateTotals.setItem(R, 1, dateItem)
self.tblDateTotals.setItem(R, 2, dateTotalItem)
self.tblDateTotals.setItem(R, 3, dateChecklistTotalItem)
lastDateTotal = date[0]
R = R + 1
self.tblYearTotals.horizontalHeader().setVisible(True)
self.tblMonthTotals.horizontalHeader().setVisible(True)
self.tblDateTotals.horizontalHeader().setVisible(True)
self.tblYearTotals.setHorizontalHeaderLabels(
['Rank', 'Year', 'Species', 'Checklists'])
self.tblYearTotals.setSortingEnabled(True)
self.tblYearTotals.sortItems(0, 0)
self.tblMonthTotals.setHorizontalHeaderLabels(
['Rank', 'Month', 'Species', 'Checklists'])
self.tblMonthTotals.setSortingEnabled(True)
self.tblMonthTotals.sortItems(0, 0)
self.tblDateTotals.setHorizontalHeaderLabels(
['Rank', 'Date', 'Species', 'Checklists'])
self.tblDateTotals.setSortingEnabled(True)
self.tblDateTotals.sortItems(0, 0)
self.tblYearTotals.removeRow(self.tblYearTotals.rowCount() - 1)
self.tblMonthTotals.removeRow(self.tblMonthTotals.rowCount() - 1)
self.tblDateTotals.removeRow(self.tblDateTotals.rowCount() - 1)
header = self.tblYearTotals.horizontalHeader()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header = self.tblMonthTotals.horizontalHeader()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header = self.tblDateTotals.horizontalHeader()
header.setSectionResizeMode(1, QHeaderView.Stretch)
self.mdiParent.SetChildDetailsLabels(self, self.filter)
self.setWindowTitle("Date Totals: " +
str(self.tblDateTotals.rowCount()) + " dates")
if self.lblDetails.text() != "":
self.lblDetails.setVisible(True)
else:
self.lblDetails.setVisible(False)
self.scaleMe()
self.resizeMe()
# tell MainWindow that all is OK
return (True)
def genHostsTabTable(self):
self.hostsTabTable.setShowGrid(True)
self.hostsTabTable.setSortingEnabled(True)
self.hostsTabTable.setRowCount(len(self.hostList))
self.hostsTabTable.setColumnCount(10)
self.hostsTabTable.setHorizontalHeaderLabels([
'Host', 'Status', 'Queue', 'Njobs', 'Ncpus', 'Ut (%)', 'Mem (G)',
'Maxmem (G)', 'swp (G)', 'maxswp (G)'
])
bhostsDic = common.getBhostsInfo()
lshostsDic = common.getLshostsInfo()
lsloadDic = common.getLsloadInfo()
hostQueueDic = common.getHostQueueInfo()
for i in range(len(self.hostList)):
host = self.hostList[i]
j = 0
self.hostsTabTable.setItem(i, j, QTableWidgetItem(host))
j = j + 1
index = bhostsDic['HOST_NAME'].index(host)
status = bhostsDic['STATUS'][index]
item = QTableWidgetItem(status)
if str(status) == 'closed':
item.setFont(QFont('song', 10, QFont.Bold))
item.setForeground(QBrush(Qt.red))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
if host in hostQueueDic.keys():
queues = ' '.join(hostQueueDic[host])
item = QTableWidgetItem(queues)
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = bhostsDic['HOST_NAME'].index(host)
njobs = bhostsDic['NJOBS'][index]
if not re.match('^[0-9]+$', njobs):
common.printWarning('*Warning*: host(' + str(host) +
') NJOBS info "' + str(njobs) +
'": invalid value, reset it to "0".')
njobs = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(njobs))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lshostsDic['HOST_NAME'].index(host)
ncpus = lshostsDic['ncpus'][index]
if not re.match('^[0-9]+$', ncpus):
common.printWarning('*Warning*: host(' + str(host) +
') ncpus info "' + str(ncpus) +
'": invalid value, reset it to "0".')
ncpus = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(ncpus))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lsloadDic['HOST_NAME'].index(host)
ut = lsloadDic['ut'][index]
ut = re.sub('%', '', ut)
if not re.match('^[0-9]+$', ut):
common.printWarning('*Warning*: host(' + str(host) +
') ut info "' + str(ut) +
'": invalid value, reset it to "0".')
ut = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(ut))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lsloadDic['HOST_NAME'].index(host)
mem = lsloadDic['mem'][index]
if re.search('M', mem):
mem = re.sub('M', '', mem)
mem = int(mem) / 1024
elif re.search('G', mem):
mem = re.sub('G', '', mem)
else:
common.printWarning('*Warning*: host(' + str(host) +
') mem info "' + str(mem) +
'": unrecognized unit, reset it to "0".')
mem = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(mem))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lshostsDic['HOST_NAME'].index(host)
maxmem = lshostsDic['maxmem'][index]
if re.search('M', maxmem):
maxmem = re.sub('M', '', maxmem)
maxmem = int(maxmem) / 1024
elif re.search('G', maxmem):
maxmem = re.sub('G', '', maxmem)
else:
common.printWarning('*Warning*: host(' + str(host) +
') maxmem info "' + str(maxmem) +
'": unrecognized unit, reset it to "0".')
maxmem = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(maxmem))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lsloadDic['HOST_NAME'].index(host)
swp = lsloadDic['swp'][index]
if re.search('M', swp):
swp = re.sub('M', '', swp)
swp = int(swp) / 1024
elif re.search('G', swp):
swp = re.sub('G', '', swp)
else:
common.printWarning('*Warning*: host(' + str(host) +
') swp info "' + str(swp) +
'": unrecognized unit, reset it to "0".')
swp = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(swp))
self.hostsTabTable.setItem(i, j, item)
j = j + 1
index = lshostsDic['HOST_NAME'].index(host)
maxswp = lshostsDic['maxswp'][index]
if re.search('M', maxswp):
maxswp = re.sub('M', '', maxswp)
maxswp = int(maxswp) / 1024
elif re.search('G', maxswp):
maxswp = re.sub('G', '', maxswp)
else:
common.printWarning('*Warning*: host(' + str(host) +
') maxswp info "' + str(maxswp) +
'": unrecognized unit, reset it to "0".')
maxswp = 0
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(maxswp))
self.hostsTabTable.setItem(i, j, item)
def populateRow(self, item, idx):
id = item['place_id']
name = item['display_name']
try:
className = QApplication.translate("nominatim", item['class'], None)
except:
className = ""
try:
typeName = QApplication.translate("nominatim", item['type'], None)
except:
typeName = ""
try:
wkt = item['geotext']
except:
wkt = None
try:
osm_type = item['osm_type']
except:
osm_type = None
bbox = {}
if osm_type == "node":
lat = item['lat']
lng = item['lon']
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn('id', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn('name', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
else:
try:
bbox = item['boundingbox']
poFD = ogr.FeatureDefn("Rectangle")
poFD.SetGeomType(ogr.wkbPolygon)
oFLD = ogr.FieldDefn('id', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn('name', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
if wkt is None:
wkt = "POLYGON(({b[2]} {b[0]}, {b[2]} {b[1]}, {b[3]} {b[1]}, {b[3]} {b[0]}, {b[2]} {b[0]}))".format(b=bbox)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
except:
lat = item['lat']
lng = item['lon']
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn('id', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn('name', ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
ogrFeature.SetGeometry(ogrGeom)
ogrFeature.SetFID(int(idx + 1))
ogrFeature.SetField(str('id'), str(id))
ogrFeature.SetField(str('name'), name)
item = QTableWidgetItem(name)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, ogrFeature)
self.tableResult.setItem(idx, 0, item)
itemLibelle = QTableWidgetItem(className)
itemLibelle.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 1, itemLibelle)
itemType = QTableWidgetItem(typeName)
itemType.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 2, itemType)
def __init__(self, plugin):
super(SettingsDialog, self).__init__()
self._plugin = plugin
# General setup of the dialog
self._plugin.logger.debug("Showing settings dialog")
self.setWindowTitle("Settings")
icon_path = self._plugin.plugin_resource("settings.png")
self.setWindowIcon(QIcon(icon_path))
self.setWindowFlags(self.windowFlags() & ~Qt.WindowCloseButtonHint)
window_widget = QWidget(self)
window_layout = QVBoxLayout(window_widget)
tabs = QTabWidget(window_widget)
window_layout.addWidget(tabs)
# "General Settings" tab
tab = QWidget(tabs)
layout = QFormLayout(tab)
layout.setFormAlignment(Qt.AlignVCenter)
tabs.addTab(tab, "General Settings")
user_widget = QWidget(tab)
user_layout = QHBoxLayout(user_widget)
layout.addRow(user_widget)
# User color
self._color_button = QPushButton("")
self._color_button.setFixedSize(50, 30)
def color_button_activated(_):
self._set_color(qt_color=QColorDialog.getColor().rgb())
self._color = self._plugin.config["user"]["color"]
self._set_color(ida_color=self._color)
self._color_button.clicked.connect(color_button_activated)
user_layout.addWidget(self._color_button)
# User name
self._name_line_edit = QLineEdit()
name = self._plugin.config["user"]["name"]
self._name_line_edit.setText(name)
user_layout.addWidget(self._name_line_edit)
text = "Disable all user cursors"
self._disable_all_cursors_checkbox = QCheckBox(text)
layout.addRow(self._disable_all_cursors_checkbox)
navbar_checked = not self._plugin.config["cursors"]["navbar"]
funcs_checked = not self._plugin.config["cursors"]["funcs"]
disasm_checked = not self._plugin.config["cursors"]["disasm"]
all_checked = navbar_checked and funcs_checked and disasm_checked
self._disable_all_cursors_checkbox.setChecked(all_checked)
def state_changed(state):
enabled = state == Qt.Unchecked
self._disable_navbar_cursors_checkbox.setChecked(not enabled)
self._disable_navbar_cursors_checkbox.setEnabled(enabled)
self._disable_funcs_cursors_checkbox.setChecked(not enabled)
self._disable_funcs_cursors_checkbox.setEnabled(enabled)
self._disable_disasm_cursors_checkbox.setChecked(not enabled)
self._disable_disasm_cursors_checkbox.setEnabled(enabled)
self._disable_all_cursors_checkbox.stateChanged.connect(state_changed)
style_sheet = """QCheckBox{ margin-left: 20px; }"""
text = "Disable navigation bar user cursors"
self._disable_navbar_cursors_checkbox = QCheckBox(text)
layout.addRow(self._disable_navbar_cursors_checkbox)
self._disable_navbar_cursors_checkbox.setChecked(navbar_checked)
self._disable_navbar_cursors_checkbox.setEnabled(not all_checked)
self._disable_navbar_cursors_checkbox.setStyleSheet(style_sheet)
text = "Disable functions window user cursors"
self._disable_funcs_cursors_checkbox = QCheckBox(text)
layout.addRow(self._disable_funcs_cursors_checkbox)
self._disable_funcs_cursors_checkbox.setChecked(funcs_checked)
self._disable_funcs_cursors_checkbox.setEnabled(not all_checked)
self._disable_funcs_cursors_checkbox.setStyleSheet(style_sheet)
text = "Disable disassembly view user cursors"
self._disable_disasm_cursors_checkbox = QCheckBox(text)
layout.addRow(self._disable_disasm_cursors_checkbox)
self._disable_disasm_cursors_checkbox.setChecked(disasm_checked)
self._disable_disasm_cursors_checkbox.setEnabled(not all_checked)
self._disable_disasm_cursors_checkbox.setStyleSheet(style_sheet)
text = "Allow other users to send notifications"
self._notifications_checkbox = QCheckBox(text)
layout.addRow(self._notifications_checkbox)
checked = self._plugin.config["user"]["notifications"]
self._notifications_checkbox.setChecked(checked)
# Log level
debug_level_label = QLabel("Logging level: ")
self._debug_level_combo_box = QComboBox()
self._debug_level_combo_box.addItem("CRITICAL", logging.CRITICAL)
self._debug_level_combo_box.addItem("ERROR", logging.ERROR)
self._debug_level_combo_box.addItem("WARNING", logging.WARNING)
self._debug_level_combo_box.addItem("INFO", logging.INFO)
self._debug_level_combo_box.addItem("DEBUG", logging.DEBUG)
self._debug_level_combo_box.addItem("TRACE", logging.TRACE)
level = self._plugin.config["level"]
index = self._debug_level_combo_box.findData(level)
self._debug_level_combo_box.setCurrentIndex(index)
layout.addRow(debug_level_label, self._debug_level_combo_box)
# "Network Settings" tab
tab = QWidget(tabs)
layout = QVBoxLayout(tab)
tab.setLayout(layout)
tabs.addTab(tab, "Network Settings")
top_widget = QWidget(tab)
layout.addWidget(top_widget)
top_layout = QHBoxLayout(top_widget)
self._servers = list(self._plugin.config["servers"])
self._servers_table = QTableWidget(len(self._servers), 2, self)
top_layout.addWidget(self._servers_table)
for i, server in enumerate(self._servers):
# Server host and port
item = QTableWidgetItem("%s:%d" % (server["host"], server["port"]))
item.setData(Qt.UserRole, server)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if self._plugin.network.server == server:
item.setFlags((item.flags() & ~Qt.ItemIsSelectable))
self._servers_table.setItem(i, 0, item)
# Server has SSL enabled?
checkbox = QTableWidgetItem()
state = Qt.Unchecked if server["no_ssl"] else Qt.Checked
checkbox.setCheckState(state)
checkbox.setFlags((checkbox.flags() & ~Qt.ItemIsEditable))
checkbox.setFlags((checkbox.flags() & ~Qt.ItemIsUserCheckable))
if self._plugin.network.server == server:
checkbox.setFlags((checkbox.flags() & ~Qt.ItemIsSelectable))
self._servers_table.setItem(i, 1, checkbox)
self._servers_table.setHorizontalHeaderLabels(("Servers", ""))
horizontal_header = self._servers_table.horizontalHeader()
horizontal_header.setSectionsClickable(False)
horizontal_header.setSectionResizeMode(0, QHeaderView.Stretch)
horizontal_header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
self._servers_table.verticalHeader().setVisible(False)
self._servers_table.setSelectionBehavior(QTableWidget.SelectRows)
self._servers_table.setSelectionMode(QTableWidget.SingleSelection)
self._servers_table.itemClicked.connect(self._server_clicked)
self._servers_table.itemDoubleClicked.connect(
self._server_double_clicked
)
self._servers_table.setMaximumHeight(100)
buttons_widget = QWidget(top_widget)
buttons_layout = QVBoxLayout(buttons_widget)
top_layout.addWidget(buttons_widget)
# Add server button
self._add_button = QPushButton("Add Server")
self._add_button.clicked.connect(self._add_button_clicked)
buttons_layout.addWidget(self._add_button)
# Edit server button
self._edit_button = QPushButton("Edit Server")
self._edit_button.setEnabled(False)
self._edit_button.clicked.connect(self._edit_button_clicked)
buttons_layout.addWidget(self._edit_button)
# Delete server button
self._delete_button = QPushButton("Delete Server")
self._delete_button.setEnabled(False)
self._delete_button.clicked.connect(self._delete_button_clicked)
buttons_layout.addWidget(self._delete_button)
bottom_widget = QWidget(tab)
bottom_layout = QFormLayout(bottom_widget)
layout.addWidget(bottom_widget)
# TCP Keep-Alive settings
keep_cnt_label = QLabel("Keep-Alive Count: ")
self._keep_cnt_spin_box = QSpinBox(bottom_widget)
self._keep_cnt_spin_box.setRange(0, 86400)
self._keep_cnt_spin_box.setValue(self._plugin.config["keep"]["cnt"])
self._keep_cnt_spin_box.setSuffix(" packets")
bottom_layout.addRow(keep_cnt_label, self._keep_cnt_spin_box)
keep_intvl_label = QLabel("Keep-Alive Interval: ")
self._keep_intvl_spin_box = QSpinBox(bottom_widget)
self._keep_intvl_spin_box.setRange(0, 86400)
self._keep_intvl_spin_box.setValue(
self._plugin.config["keep"]["intvl"]
)
self._keep_intvl_spin_box.setSuffix(" seconds")
bottom_layout.addRow(keep_intvl_label, self._keep_intvl_spin_box)
keep_idle_label = QLabel("Keep-Alive Idle: ")
self._keep_idle_spin_box = QSpinBox(bottom_widget)
self._keep_idle_spin_box.setRange(0, 86400)
self._keep_idle_spin_box.setValue(self._plugin.config["keep"]["idle"])
self._keep_idle_spin_box.setSuffix(" seconds")
bottom_layout.addRow(keep_idle_label, self._keep_idle_spin_box)
# Buttons commons to all tabs
actions_widget = QWidget(self)
actions_layout = QHBoxLayout(actions_widget)
# Cancel = do not save the changes and close the dialog
def cancel(_):
self.reject()
cancel_button = QPushButton("Cancel")
cancel_button.clicked.connect(cancel)
actions_layout.addWidget(cancel_button)
# Reset = reset all settings from all tabs to default values
reset_button = QPushButton("Reset")
reset_button.clicked.connect(self._reset)
actions_layout.addWidget(reset_button)
# Save = save the changes and close the dialog
def save(_):
self._commit()
self.accept()
save_button = QPushButton("Save")
save_button.clicked.connect(save)
actions_layout.addWidget(save_button)
window_layout.addWidget(actions_widget)
# Do not allow the user to resize the dialog
self.setFixedSize(
window_widget.sizeHint().width(), window_widget.sizeHint().height()
)
def calc_sterimol(self, *args):
self.settings.radii = self.radii_option.currentText()
self.settings.display_radii = self.display_radii.checkState(
) == Qt.Checked
self.settings.display_vectors = self.display_vectors.checkState(
) == Qt.Checked
targets, neighbors, datas = sterimol_cmd(
self.session,
selected_atoms(self.session),
radii=self.radii_option.currentText(),
showVectors=self.display_vectors.checkState() == Qt.Checked,
showRadii=self.display_radii.checkState() == Qt.Checked,
return_values=True,
)
if len(targets) == 0:
return
self.table.setRowCount(0)
for t, b, data in zip(targets, neighbors, datas):
row = self.table.rowCount()
self.table.insertRow(row)
targ = QTableWidgetItem()
targ.setData(Qt.DisplayRole, t)
self.table.setItem(row, 0, targ)
neigh = QTableWidgetItem()
neigh.setData(Qt.DisplayRole, b)
self.table.setItem(row, 1, neigh)
l = np.linalg.norm(data["L"][1] - data["L"][0])
b1 = np.linalg.norm(data["B1"][1] - data["B1"][0])
b2 = np.linalg.norm(data["B2"][1] - data["B2"][0])
b3 = np.linalg.norm(data["B3"][1] - data["B3"][0])
b4 = np.linalg.norm(data["B4"][1] - data["B4"][0])
b5 = np.linalg.norm(data["B5"][1] - data["B5"][0])
li = QTableWidgetItem()
li.setData(Qt.DisplayRole, "%.2f" % l)
self.table.setItem(row, 7, li)
b1i = QTableWidgetItem()
b1i.setData(Qt.DisplayRole, "%.2f" % b1)
self.table.setItem(row, 2, b1i)
b2i = QTableWidgetItem()
b2i.setData(Qt.DisplayRole, "%.2f" % b2)
self.table.setItem(row, 3, b2i)
b3i = QTableWidgetItem()
b3i.setData(Qt.DisplayRole, "%.2f" % b3)
self.table.setItem(row, 4, b3i)
b4i = QTableWidgetItem()
b4i.setData(Qt.DisplayRole, "%.2f" % b4)
self.table.setItem(row, 5, b4i)
b5i = QTableWidgetItem()
b5i.setData(Qt.DisplayRole, "%.2f" % b5)
self.table.setItem(row, 6, b5i)
def set_info(self):
self.tw_adres.horizontalHeader().resizeSection(0, 120)
self.tw_adres.horizontalHeader().resizeSection(1, 300)
self.tw_adres.horizontalHeader().resizeSection(2, 80)
self.tw_vendor_number.horizontalHeader().resizeSection(0, 120)
self.tw_vendor_number.horizontalHeader().resizeSection(1, 120)
self.tw_vendor_number.horizontalHeader().resizeSection(2, 120)
if self.select_id == "new":
self.pb_add_file.setEnabled(False)
self.pb_open_file.setEnabled(False)
else:
query = """SELECT Name, Legal_Address, Actual_Address, INN, KPP, OGRN, Account, Bank, corres_Account,
BIK, Contact_Person, Phone, Mail, Note, No_Nds, Full_Name FROM clients WHERE Id = %s"""
info_client = my_sql.sql_select(query, (self.select_id, ))
if "mysql.connector.errors" in str(type(info_client)):
QMessageBox.critical(self, "Ошибка sql вывод клиента",
info_client.msg, QMessageBox.Ok)
return False
self.le_name.setText(info_client[0][0])
self.le_legal_address.setText(info_client[0][1])
self.le_actual_address.setText(info_client[0][2])
self.le_inn.setText(info_client[0][3])
self.le_kpp.setText(info_client[0][4])
self.le_ogrn.setText(info_client[0][5])
self.le_rs.setText(info_client[0][6])
self.le_bank.setText(info_client[0][7])
self.le_ks.setText(info_client[0][8])
self.le_bik.setText(info_client[0][9])
self.le_fio.setText(info_client[0][10])
self.le_phone.setText(info_client[0][11])
self.le_mail.setText(info_client[0][12])
self.le_note.appendPlainText(info_client[0][13])
if info_client[0][14]:
self.cb_nds.setChecked(True)
self.le_full_name.setText(info_client[0][15])
query = """SELECT Id, Name, Adres, KPP FROM clients_actual_address WHERE Client_Id = %s"""
info_client = my_sql.sql_select(query, (self.select_id, ))
if "mysql.connector.errors" in str(type(info_client)):
QMessageBox.critical(self, "Ошибка sql вывод адресов клиента",
info_client.msg, QMessageBox.Ok)
return False
row = 0
for item in info_client:
self.tw_adres.insertRow(self.tw_adres.rowCount())
table_item = QTableWidgetItem(item[1])
table_item.setData(-1, item[0])
self.tw_adres.setItem(row, 0, table_item)
table_item = QTableWidgetItem(item[2])
self.tw_adres.setItem(row, 1, table_item)
table_item = QTableWidgetItem(item[3])
self.tw_adres.setItem(row, 2, table_item)
row += 1
query = """SELECT Id, Number, Contract, Data_From FROM clients_vendor_number WHERE Client_Id = %s"""
info_client = my_sql.sql_select(query, (self.select_id, ))
if "mysql.connector.errors" in str(type(info_client)):
QMessageBox.critical(self, "Ошибка sql вывод адресов клиента",
info_client.msg, QMessageBox.Ok)
return False
row = 0
for item in info_client:
self.tw_vendor_number.insertRow(
self.tw_vendor_number.rowCount())
table_item = QTableWidgetItem(item[1])
table_item.setData(-1, item[0])
self.tw_vendor_number.setItem(row, 0, table_item)
table_item = QTableWidgetItem(item[2])
self.tw_vendor_number.setItem(row, 1, table_item)
table_item = QTableWidgetItem(item[3].strftime("%d.%m.%Y"))
self.tw_vendor_number.setItem(row, 2, table_item)
row += 1
self.inspection_files(self.le_name.text().replace('.', '').strip(),
"Путь корень клиенты")
def calc(self):
# Проверим записаные суммы в крое
query = """SELECT transaction_records_material.Note, transaction_records_material.Balance, transaction_records_material.Id
FROM transaction_records_material LEFT JOIN material_balance ON transaction_records_material.Supply_Balance_Id = material_balance.Id
LEFT JOIN material_supplyposition ON material_balance.Material_SupplyPositionId = material_supplyposition.Id
LEFT JOIN material_name ON material_supplyposition.Material_NameId = material_name.Id
WHERE Cut_Material_Id = %s"""
sql_info = my_sql.sql_select(query, (self.id,))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 1", sql_info.msg, QMessageBox.Ok)
return False
pack = {}
for transaction in sql_info:
search_pack = findall(r"\d+/(\d+) - ", transaction[0])
if search_pack:
search_pack = int(search_pack[0])
else:
search_pack = 0
i = pack.setdefault(search_pack, {"count": 0, "balance": 0, "t_id": []})
i["count"] += 1
i["t_id"].append(transaction[2])
if transaction[1]:
i["balance"] += transaction[1]
sum_transaction, sum_info, sum_res = 0, 0, 0
for key, item_key in pack.items():
# Проверим записаные веса в пачке
query = """SELECT pack.Weight + IFNULL(pack_add_material.Weight + pack_add_material.Weight_Rest, 0)
FROM pack LEFT JOIN pack_add_material ON pack.Id = pack_add_material.Pack_Id
WHERE pack.Cut_Id = %s AND pack.Number = %s"""
sql_info = my_sql.sql_select(query, (self.id, key))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка поиска пачки", sql_info.msg, QMessageBox.Ok)
return False
if sql_info and sql_info[0][0] and -sql_info[0][0] == item_key["balance"]:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(252, 141, 141, 255))
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(str(key))
item.setBackground(color)
item.setData(5, item_key["t_id"])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
item = QTableWidgetItem(str(item_key["count"]))
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
item = QTableWidgetItem(str(item_key["balance"]))
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
sum_transaction += item_key["balance"]
if sql_info:
item = QTableWidgetItem(str(sql_info[0][0]))
sum_info += sql_info[0][0]
else:
item = QTableWidgetItem("Нету")
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
if sql_info:
res = -item_key["balance"] - sql_info[0][0]
sum_res += res
else:
res = None
item = QTableWidgetItem(str(res))
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
else:
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(str(sum_transaction))
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
item = QTableWidgetItem(str(sum_info))
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
item = QTableWidgetItem(str(sum_res))
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
def clear_bonus_template(self):
for r in range(3):
for c in range(5):
item = QTableWidgetItem()
item.setData(Qt.EditRole, 0)
self.view.custom_bonus_table.setItem(r, c, item)
def ui_test(self):
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
# Проверим нужно ли применять фильтр
if self.rb_filter_no.isChecked():
query = "SELECT cut.Id FROM cut ORDER BY cut.Id"
elif self.rb_filter_date.isChecked():
query = "SELECT cut.Id FROM cut WHERE cut.Date_Cut >= '%s' ORDER BY cut.Id" % self.de_date_from.date().toString(Qt.ISODate)
elif self.rb_filter_num.isChecked():
query = "SELECT cut.Id FROM cut WHERE cut.Id >= %s ORDER BY cut.Id" % self.le_cut_num.text()
else:
QMessageBox.critical(self, "Фильтр", "Что то не так с фильтром", QMessageBox.Ok)
return False
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение приходов материала", sql_info.msg, QMessageBox.Ok)
return False
cut_id_list = [i[0] for i in sql_info]
for cut_id in cut_id_list:
self.statusBar.showMessage("Расчет кроя %s" % cut_id)
# Проверим записаные суммы в крое
query = """SELECT cut.Weight_Rest +cut.Weight_Pack_All, material_name.Name
FROM cut LEFT JOIN material_name ON cut.Material_Id = material_name.Id
WHERE cut.Id = %s"""
sql_info = my_sql.sql_select(query, (cut_id,))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 1", sql_info.msg, QMessageBox.Ok)
return False
res1 = sql_info[0][0]
main_material = sql_info[0][1]
# Проверим сумму взятую с пачек
query = """SELECT c.Weight_Rest + (SELECT SUM(p.Weight) FROM pack as p WHERE p.Cut_Id = c.Id)
FROM cut as c WHERE c.Id = %s"""
sql_info = my_sql.sql_select(query, (cut_id,))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 2/1", sql_info.msg, QMessageBox.Ok)
return False
res2 = sql_info[0][0]
# сумируем сумму пачек и доп ткани
query = """SELECT SUM(pack_add_material.Weight_Rest + pack_add_material.Weight), material_name.Name
FROM pack_add_material LEFT JOIN pack ON pack_add_material.Pack_Id = pack.Id
LEFT JOIN material_name ON pack_add_material.Material_Name_Id = material_name.Id
WHERE pack.Cut_Id = %s"""
sql_info = my_sql.sql_select(query, (cut_id,))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 2/2", sql_info.msg, QMessageBox.Ok)
return False
if sql_info[0][0]:
res2 += sql_info[0][0]
add_material = sql_info[0][1]
# Проверим сумму транзакций
query = """SELECT SUM(Balance)
FROM transaction_records_material
WHERE transaction_records_material.Cut_Material_Id = %s"""
sql_info = my_sql.sql_select(query, (cut_id,))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 3", sql_info.msg, QMessageBox.Ok)
return False
if sql_info[0][0]:
res3 = -sql_info[0][0]
else:
res3 = None
if res1 == res2 == res3:
color = QBrush(QColor(150, 255, 161, 255))
status = 1
elif res1 != res2 == res3:
color = QBrush(QColor(255, 255, 153, 255))
status = 2
else:
color = QBrush(QColor(252, 141, 141, 255))
status = 3
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(str(cut_id))
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
item = QTableWidgetItem(str(res1))
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
item = QTableWidgetItem(str(res2))
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
item = QTableWidgetItem(str(res3))
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
item = QTableWidgetItem(main_material)
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
item = QTableWidgetItem(add_material)
item.setData(5, cut_id)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 5, item)
def set_vote_placeholder(row):
mv = QTableWidgetItem()
mv.setData(Qt.DisplayRole, "Voting...")
mv.setData(Qt.TextAlignmentRole, Qt.AlignCenter)
self.setItem(row, FundColumns.MYVOTE, mv);
def ui_test(self):
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
# Проверим нужно ли применять фильтр
if self.rb_filter_no.isChecked():
query = "SELECT pack.Id FROM cut LEFT JOIN pack ON cut.Id = pack.Cut_Id ORDER BY cut.Id"
elif self.rb_filter_date.isChecked():
query = "SELECT pack.Id FROM cut LEFT JOIN pack ON cut.Id = pack.Cut_Id WHERE cut.Date_Cut >= '%s' ORDER BY cut.Id" % self.de_date_from.date().toString(Qt.ISODate)
elif self.rb_filter_num.isChecked():
query = "SELECT pack.Id FROM cut LEFT JOIN pack ON cut.Id = pack.Cut_Id WHERE cut.Id >= %s ORDER BY cut.Id" % self.le_cut_num.text()
else:
QMessageBox.critical(self, "Фильтр", "Что то не так с фильтром", QMessageBox.Ok)
return False
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение приходов материала", sql_info.msg, QMessageBox.Ok)
return False
pack_id_list = [i[0] for i in sql_info]
pack_id_list_str = str(pack_id_list).replace("[", "").replace("]", "").replace("None,", "")
# Проверим записаные суммы в крое
query = """SELECT Pack_Id, SUM(Value * Value_Thing)
FROM pack_accessories
WHERE Pack_Id IN (%s)
GROUP BY pack_accessories.Pack_Id""" % pack_id_list_str
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 1", sql_info.msg, QMessageBox.Ok)
return False
res1 = sql_info
# Проверим сумму взятую с пачек
query = """SELECT pack_accessories.Pack_Id, SUM(Balance)
FROM transaction_records_accessories
LEFT JOIN pack_accessories ON transaction_records_accessories.Pack_Accessories_Id = pack_accessories.Id
WHERE pack_accessories.Pack_Id IN (%s)
GROUP BY pack_accessories.Pack_Id""" % pack_id_list_str
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql 2", sql_info.msg, QMessageBox.Ok)
return False
res2 = sql_info
res = {}
for i in res1+res2:
res.setdefault(i[0], []).append(i[1])
for key, val in res.items():
self.statusBar.showMessage("Расчет пачки %s" % key)
if val[0] == -val[1]:
color = QBrush(QColor(150, 255, 161, 255))
status = 1
else:
color = QBrush(QColor(252, 141, 141, 255))
status = 2
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(str(key))
item.setData(5, key)
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
item = QTableWidgetItem(str(val[0]))
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
item = QTableWidgetItem(str(val[1]))
item.setData(-1, status)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
def __init__(self, plugin, repos, branches):
"""
Initialize the open dialog.
:param plugin: the plugin instance
:param repos: the list of repositories
:param branches: the list of branches
"""
super(OpenDialog, self).__init__()
self._plugin = plugin
self._repos = repos
self._branches = branches
# General setup of the dialog
logger.debug("Showing open database dialog")
self.setWindowTitle("Open from Remote Server")
iconPath = self._plugin.resource('download.png')
self.setWindowIcon(QIcon(iconPath))
self.resize(900, 450)
# Setup of the layout and widgets
layout = QHBoxLayout(self)
self._reposTable = QTableWidget(len(repos), 1, self)
self._reposTable.setHorizontalHeaderLabels(('Remote Repositories',))
for i, repo in enumerate(repos):
item = QTableWidgetItem("%s (%s)" % (str(repo.file),
str(repo.hash)))
item.setData(Qt.UserRole, repo)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self._reposTable.setItem(i, 0, item)
self._reposTable.horizontalHeader().setSectionsClickable(False)
self._reposTable.horizontalHeader().setStretchLastSection(True)
self._reposTable.verticalHeader().setVisible(False)
self._reposTable.setSelectionBehavior(QTableWidget.SelectRows)
self._reposTable.setSelectionMode(QTableWidget.SingleSelection)
self._reposTable.itemClicked.connect(self._repo_clicked)
minSZ = self._reposTable.minimumSize()
self._reposTable.setMinimumSize(300, minSZ.height())
maxSZ = self._reposTable.maximumSize()
self._reposTable.setMaximumSize(300, maxSZ.height())
layout.addWidget(self._reposTable)
rightSide = QWidget(self)
rightLayout = QVBoxLayout(rightSide)
infoGroup = QGroupBox("Information", rightSide)
infoLayout = QGridLayout(infoGroup)
self._fileLabel = QLabel('<b>File:</b>')
infoLayout.addWidget(self._fileLabel, 0, 0)
self._hashLabel = QLabel('<b>Hash:</b>')
infoLayout.addWidget(self._hashLabel, 1, 0)
infoLayout.setColumnStretch(0, 1)
self._typeLabel = QLabel('<b>Type:</b>')
infoLayout.addWidget(self._typeLabel, 0, 1)
self._dateLabel = QLabel('<b>Date:</b>')
infoLayout.addWidget(self._dateLabel, 1, 1)
infoLayout.setColumnStretch(1, 1)
rightLayout.addWidget(infoGroup)
branchesGroup = QGroupBox("Branches", rightSide)
branchesLayout = QGridLayout(branchesGroup)
self._branchesTable = QTableWidget(0, 2, branchesGroup)
self._branchesTable.setHorizontalHeaderLabels(('Identifier', 'Date'))
horizontalHeader = self._branchesTable.horizontalHeader()
horizontalHeader.setSectionsClickable(False)
horizontalHeader.setSectionResizeMode(0, horizontalHeader.Stretch)
self._branchesTable.verticalHeader().setVisible(False)
self._branchesTable.setSelectionBehavior(QTableWidget.SelectRows)
self._branchesTable.setSelectionMode(QTableWidget.SingleSelection)
self._branchesTable.itemClicked.connect(self._branch_clicked)
branchesLayout.addWidget(self._branchesTable, 0, 0)
rightLayout.addWidget(branchesGroup)
buttonsWidget = QWidget(rightSide)
buttonsLayout = QHBoxLayout(buttonsWidget)
buttonsLayout.addStretch()
self._openButton = QPushButton("Open")
self._openButton.setEnabled(False)
self._openButton.clicked.connect(self.accept)
buttonsLayout.addWidget(self._openButton)
cancelButton = QPushButton("Cancel")
cancelButton.clicked.connect(self.reject)
buttonsLayout.addWidget(cancelButton)
rightLayout.addWidget(buttonsWidget)
layout.addWidget(rightSide)
def build_aa_layout(self, pak):
trees_id = self.get_tree_tabs(pak)
trees_info = eq2s_func.get_db_content('aatree', 'id', trees_id)
self.aa_maxpoints = {}
self.aa_clickedpoints = {}
self.aa_points_display = {}
# store aa tabs
self.aa_tables = {}
tradeskilltabs = []
# adventure tabs
for each in sorted(trees_id):
name = trees_info[each]['name']
# store all tradeskill aa tab into a list, and make all of them next to adventure tabs.
if name in ['Tradeskill', 'General', 'Far Seas']:
tradeskilltabs.append(each)
continue
# jumping to tabs creating function
tab = self.create_tabs(each)
self.aa_maxpoints[each] = trees_info[each][
'maxpointsperlevelnode_list'][-1]['maxpoints']
self.aa_clickedpoints[each] = 0
self.aa_points_display[each].setText('{} / {}'.format(
self.aa_clickedpoints[each], self.aa_maxpoints[each]))
self.tab_widget.addTab(tab, name)
# tradeskill tabs
for each in tradeskilltabs:
tab = self.create_tabs(each)
self.aa_maxpoints[each] = trees_info[each][
'maxpointsperlevelnode_list'][-1]['maxpoints']
self.aa_clickedpoints[each] = 0
self.aa_points_display[each].setText('{} / {}'.format(
self.aa_clickedpoints[each], self.aa_maxpoints[each]))
self.tab_widget.addTab(tab, trees_info[each]['name'])
self.splnodes = {}
# construct the aa layout
try:
for e1 in trees_info:
grid_n = eq2s_func.get_aa_tree_grid_modifier(
trees_info[e1]['name'])
for e2 in trees_info[e1]['alternateadvancementnode_list']:
epicon = QTableWidgetItem()
epicon.setFont(QFont("Times", 15, QFont.Black))
# get the crc group spells from local databases, cuz only one target provide,
# so I just extract the only list from the returned dict.
crcs = eq2s_func.get_db_content(
'crcspl', 'crc', (e2['spellcrc'], ))[e2['spellcrc']]
# this dict intend to save ordered level(tier) crc spells, the keys means tier of this spell.
crcdict = {}
for each in crcs:
crcdict[each['tier']] = each
epicon.setData(1000, crcdict)
self.splnodes[e2['nodeid']] = epicon
epicon.setToolTip(eq2s_func.CookSpellText(crcs[0]))
icon = QIcon()
iconid = epicon.data(1000)[1]['icon']['id']
# backiconid = epicon.data(1000)[0]['icon']['backdrop']
icon.addPixmap(
eq2s_func.get_pixmap_in_db(iconid, 'spellicons'))
# epicon.setBackground(QBrush(eq2s_func.get_pixmap_in_db(backiconid, 'spellicons')))
epicon.setIcon(icon)
self.aa_tables[e1].setItem(
int(e2['ycoord'] * grid_n['y'] + 1),
int(e2['xcoord'] * grid_n['x'] + 1), epicon)
except BaseException as err:
QMessageBox().critical(self, 'Loading Error',
'Something Bad Happen:\n{}'.format(err))
print(err)
return
self.fresh_tables()
self.throw_aas(pak)
def FillPieChart(self):
self.tblPieChartLegend.clear()
QApplication.processEvents()
self.tblPieChartLegend.setColumnCount(3)
self.tblPieChartLegend.setRowCount(len(self.familiesList))
self.tblPieChartLegend.horizontalHeader().setVisible(False)
header = self.tblPieChartLegend.horizontalHeader()
header.setSectionResizeMode(1, QHeaderView.Stretch)
self.tblPieChartLegend.setShowGrid(False)
colors = []
familiesCount = []
set_angle = 0
R = 0
for f in self.familiesList:
familiesCount.append(
sum(
x.count(str(f))
for x in self.filteredSpeciesListWithFamilies))
total = sum(familiesCount)
for fl in range(len(self.familiesList)):
number = []
# randomly create three color values (rgb)
for rgb in range(3):
number.append(random.randrange(0, 255))
colors.append(QColor(number[0], number[1], number[2]))
scene = QGraphicsScene()
for family in familiesCount:
# create the angle of each wedge according to its perecent of 360
angle = round(family / total * 16 * 360)
# set size of circle and create wedge
ellipse = self.MyEllipse(0, 0, 100, 100)
# set the tooltip for the ellipse wedge
ellipse.setToolTip(self.familiesList[R] + ": " + str(family))
# set center of circle, like an axle
ellipse.setPos(0, 0)
# rotate through the wedge
ellipse.setStartAngle(set_angle)
ellipse.setSpanAngle(angle)
# assign color
ellipse.setBrush(colors[R])
# turn off pen so we won't have ellipse borders
pen = QPen()
pen.setWidthF(.1)
ellipse.setPen(pen)
# create set_angle for next time around
set_angle = angle + set_angle
# add the actual wedge to the scene object
scene.addItem(ellipse)
# save meta data to ellipse for future use (e.g., clicks)
ellipse.family = self.familiesList[R]
ellipse.parent = self
# add entry to legend table and set proper color
colorItem = QTableWidgetItem()
colorItem.setBackground(QColor(colors[R]))
familyNameItem = QTableWidgetItem()
familyNameItem.setData(Qt.DisplayRole, self.familiesList[R])
familyCountItem = QTableWidgetItem()
familyCountItem.setData(Qt.DisplayRole, family)
self.tblPieChartLegend.setItem(R, 0, colorItem)
self.tblPieChartLegend.setItem(R, 1, familyNameItem)
self.tblPieChartLegend.setItem(R, 2, familyCountItem)
R = R + 1
self.gvPieChart.setScene(scene)
self.fitPieChart()
return (True)
class GalleryDownloaderItem(QObject):
"""
HenItem wrapper
"""
d_item_ready = pyqtSignal(object)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.d_item_ready.connect(self.done)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setData(Qt.UserRole + 1, hitem)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('In queue...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
_type = 'Unknown'
if hitem.download_type == app_constants.DOWNLOAD_TYPE_ARCHIVE:
_type = 'Archive'
if hitem.download_type == app_constants.DOWNLOAD_TYPE_OTHER:
_type = 'Other'
if hitem.download_type == app_constants.DOWNLOAD_TYPE_TORRENT:
_type = 'Torrent'
self.type_item = QTableWidgetItem(_type)
self.type_item.setToolTip(url)
self.status_timer = QTimer()
self.status_timer.timeout.connect(self.check_progress)
self.status_timer.start(500)
def check_progress(self):
if self.item.current_state == self.item.DOWNLOADING:
btomb = 1048576
self.status_item.setText("{0:.2f}/{1:.2f} MB".format(
self.item.current_size / btomb, self.item.total_size / btomb))
self.size_item.setText("{0:.2f} MB".format(self.item.total_size /
btomb))
elif self.item.current_state == self.item.CANCELLED:
self.status_item.setText("Cancelled!")
self.status_timer.stop()
def done(self):
self.status_timer.stop()
if self.item.download_type == app_constants.DOWNLOAD_TYPE_TORRENT:
self.status_item.setText("Sent to torrent client!")
else:
self.status_item.setText("Creating gallery...")
def show_all_advertisement(self, advertisements):
""" 显示系统中所有广告信息供管理 """
self.ad_table.clearContents()
self.ad_table.setRowCount(len(advertisements))
for row, ad_item in enumerate(advertisements):
item0 = QTableWidgetItem(str(ad_item["id"]))
item0.setTextAlignment(Qt.AlignCenter)
self.ad_table.setItem(row, 0, item0)
item1 = QTableWidgetItem(ad_item["title"])
item1.setTextAlignment(Qt.AlignCenter)
self.ad_table.setItem(row, 1, item1)
item2 = QTableWidgetItem(self.AD_TYPE.get(ad_item["ad_type"],
'未知'))
item2.setTextAlignment(Qt.AlignCenter)
item2.setData(Qt.UserRole, ad_item["ad_type"])
self.ad_table.setItem(row, 2, item2)
item3 = QTableWidgetItem("查看图片")
item3.setTextAlignment(Qt.AlignCenter)
item3.setData(Qt.UserRole, ad_item["image"])
self.ad_table.setItem(row, 3, item3)
item4 = QTableWidgetItem("查看文件")
item4.setData(Qt.UserRole, ad_item["filepath"])
item4.setTextAlignment(Qt.AlignCenter)
self.ad_table.setItem(row, 4, item4)
item5 = QTableWidgetItem("查看网址")
item5.setTextAlignment(Qt.AlignCenter)
item5.setData(Qt.UserRole, ad_item["web_url"])
self.ad_table.setItem(row, 5, item5)
item6 = QTableWidgetItem("查看内容")
item6.setTextAlignment(Qt.AlignCenter)
item6.setData(Qt.UserRole, ad_item["content"])
self.ad_table.setItem(row, 6, item6)
item7 = QTableWidgetItem("备注")
item7.setForeground(QBrush(QColor(66, 66, 233)))
item7.setData(Qt.UserRole, ad_item["note"])
item7.setTextAlignment(Qt.AlignCenter)
self.ad_table.setItem(row, 7, item7)
text, q_color = ("启用", QColor(
66, 233,
66)) if ad_item["is_active"] else ("未启用", QColor(233, 66, 66))
item8 = QTableWidgetItem(text)
item8.setForeground(QBrush(q_color))
item8.setTextAlignment(Qt.AlignCenter)
self.ad_table.setItem(row, 8, item8)
def ui_calc(self):
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
query = """SELECT clients.Id, clients.Name, `order`.Number_Doc, `order`.Number_Order, `order`.Date_Shipment,
`order`.Sum_Off_Nds, `order`.Sum_In_Nds, SUM(order_position.Value)
FROM `order` LEFT JOIN order_position ON `order`.Id = order_position.Order_Id
LEFT JOIN clients ON `order`.Client_Id = clients.Id
WHERE `order`.Date_Shipment >= %s AND `order`.Date_Shipment <= %s AND `order`.Shipped = 1 GROUP BY `order`.Id ORDER BY clients.Id"""
sql_info = my_sql.sql_select(query,
(self.de_date_from.date().toPyDate(),
self.de_date_to.date().toPyDate()))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self,
"Ошибка sql получения отгруженных зказов",
sql_info.msg, QMessageBox.Ok)
return False
sum_off_nds, sum_in_nds, sum_value = 0, 0, 0
all_sum_off_nds, all_sum_in_nds, all_sum_value = 0, 0, 0
old_client_id = None
for order in sql_info:
if order[0] != old_client_id: # Если новый клиент не равен предыдущемо делаем подсчет!
if old_client_id is None: # Если это первая итерация то просто белем ID клиента и мдем дальше!
old_client_id = order[0]
else:
all_sum_off_nds += sum_off_nds
all_sum_in_nds += sum_in_nds
all_sum_value += sum_value
self.tableWidget.insertRow(self.tableWidget.rowCount())
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ',
str(sum_off_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1,
4, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ',
str(sum_in_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1,
5, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ',
str(sum_value))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1,
6, item)
sum_off_nds, sum_in_nds, sum_value = 0, 0, 0
old_client_id = order[0]
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(order[1])
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
item = QTableWidgetItem(str(order[2]))
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
item = QTableWidgetItem(str(order[3]))
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
item = QTableWidgetItem(order[4].strftime("%d.%m.%Y"))
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
sum_off_nds += order[5]
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(order[5]))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
sum_in_nds += order[6]
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(order[6]))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 5, item)
sum_value += order[7]
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(order[7]))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 6, item)
else:
# Вставляем сумму для последнего клиента
all_sum_off_nds += sum_off_nds
all_sum_in_nds += sum_in_nds
all_sum_value += sum_value
self.tableWidget.insertRow(self.tableWidget.rowCount())
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(sum_off_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(sum_in_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 5, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(sum_value))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 6, item)
# Вставляем итоговоую сумму
self.tableWidget.insertRow(self.tableWidget.rowCount())
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ',
str(all_sum_off_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(all_sum_in_nds))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 5, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(all_sum_value))
item = QTableWidgetItem(text)
item.setData(5, order[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 6, item)
def FillSpecies(self, filter):
self.filter = filter
self.listType = "Species"
checklistDetails = ""
# set up a bold font to use in columns as needed
font = QFont()
font.setBold(True)
if filter.getLocationType() == "Location":
self.btnShowLocation.setVisible(True)
# set up tblList column headers and widths
self.tblList.setShowGrid(False)
header = self.tblList.horizontalHeader()
header.setVisible(True)
# if this is a species list (not a single checklist), get data and set 4 columns
if filter.getChecklistID() == "":
thisWindowList = self.mdiParent.db.GetSpeciesWithData(
filter, [], "Subspecies")
thisCleanedWindowList = []
# clean out spuh and slash entries
for s in range(len(thisWindowList)):
if not ("sp." in thisWindowList[s][0]
or "/" in thisWindowList[s][0]):
thisCleanedWindowList.append(thisWindowList[s])
thisWindowList = thisCleanedWindowList
if len(thisWindowList) == 0:
return (False)
self.tblList.setRowCount(len(thisWindowList))
self.tblList.setColumnCount(6)
self.tblList.setHorizontalHeaderLabels([
'Tax', 'Species', 'First', 'Last', 'Checklists',
'% of Checklists'
])
header.setSectionResizeMode(1, QHeaderView.Stretch)
self.tblList.setItemDelegateForColumn(
5, code_FloatDelegate.FloatDelegate(2))
# add species and dates to table row by row
R = 0
for species in thisWindowList:
taxItem = QTableWidgetItem()
taxItem.setData(Qt.DisplayRole, R + 1)
speciesItem = QTableWidgetItem()
speciesItem.setText(species[0])
speciesItem.setData(Qt.UserRole, QVariant(species[4]))
firstItem = QTableWidgetItem()
firstItem.setData(Qt.DisplayRole, species[1])
lastItem = QTableWidgetItem()
lastItem.setData(Qt.DisplayRole, species[2])
self.tblList.setItem(R, 0, taxItem)
checklistCountItem = QTableWidgetItem()
checklistCountItem.setData(Qt.DisplayRole, species[5])
checklistCountItem.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
percentageItem = QTableWidgetItem()
percentageItem.setData(Qt.DisplayRole, species[6])
self.tblList.setItem(R, 1, speciesItem)
self.tblList.item(R, 1).setFont(font)
self.tblList.item(R, 1).setForeground(Qt.blue)
self.tblList.setItem(R, 2, firstItem)
self.tblList.setItem(R, 3, lastItem)
self.tblList.setItem(R, 4, checklistCountItem)
self.tblList.setItem(R, 5, percentageItem)
self.currentSpeciesList.append(species[0])
R = R + 1
# hide the checklist comments box, since we're not showing a single checklist
self.txtChecklistComments.setVisible(False)
self.tblList.addAction(self.actionSetFirstDateFilter)
self.tblList.addAction(self.actionSetLastDateFilter)
self.tblList.addAction(self.actionSetSpeciesFilter)
# if this is limited to a checklist, set 3 columns
else:
self.listType = "Single Checklist"
thisWindowList = self.mdiParent.db.GetSightings(filter)
self.tblList.setRowCount(len(thisWindowList))
self.tblList.setColumnCount(4)
self.tblList.setHorizontalHeaderLabels(
['Tax', 'Species', 'Count', "Comment"])
header.setSectionResizeMode(1, QHeaderView.Stretch)
self.tblList.setWordWrap(True)
# add species and dates to table row by row
R = 0
for s in thisWindowList:
taxItem = QTableWidgetItem()
taxItem.setData(Qt.DisplayRole, R + 1)
speciesItem = QTableWidgetItem()
speciesItem.setText(s["commonName"])
speciesItem.setData(Qt.UserRole, QVariant(s["commonName"]))
countItem = QTableWidgetItem()
count = s["count"]
if count != "X":
count = int(count)
countItem.setData(Qt.DisplayRole, count)
countItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
commentItem = QTableWidgetItem()
commentItem.setText(s["speciesComments"])
self.tblList.setItem(R, 0, taxItem)
self.tblList.setItem(R, 1, speciesItem)
self.tblList.item(R, 1).setFont(font)
self.tblList.item(R, 1).setForeground(Qt.blue)
self.tblList.setItem(R, 2, countItem)
self.tblList.setItem(R, 3, commentItem)
self.currentSpeciesList.append(s["commonName"])
R = R + 1
# resize all rows as necessary to show full comments
# without this call, Qt sometimes truncates the comments
# shorten the height of tblList to create room for checklist comments box
self.txtChecklistComments.setVisible(True)
# fill checklist comments text
checklistComments = thisWindowList[0]["checklistComments"]
if checklistComments == "":
checklistComments = "No checklist comments."
self.txtChecklistComments.appendPlainText(checklistComments)
#fill checklist details of time, distance, and checklist protoccol
time = thisWindowList[0]["time"]
protocol = thisWindowList[0]["protocol"]
duration = thisWindowList[0]["duration"]
distance = thisWindowList[0]["distance"]
observerCount = thisWindowList[0]["observers"]
if time != "":
time = time + ", "
if duration != "0":
duration = duration + " min, "
else:
duration = ""
if distance != "":
distance = distance + " km, "
if observerCount != "":
observerCount = observerCount + " obs, "
if "Traveling" in protocol:
protocol = "Traveling"
if "Stationary" in protocol:
protocol = "Stationary"
if "Casual" in protocol:
protocol = "Casual"
checklistDetails = (time + duration + distance + observerCount +
protocol)
self.tblList.addAction(self.actionSetDateFilter)
self.tblList.addAction(self.actionSetSpeciesFilter)
self.tblList.addAction(self.actionSetLocationFilter)
speciesCount = self.mdiParent.db.CountSpecies(self.currentSpeciesList)
self.lblSpecies.setText("Species: " + str(speciesCount))
if speciesCount != self.tblList.rowCount():
self.lblSpecies.setText("Species: " + str(speciesCount) +
" plus " + str(self.tblList.rowCount() -
speciesCount) +
" other taxa")
self.mdiParent.SetChildDetailsLabels(self, filter)
if checklistDetails != "":
self.lblDetails.setText(checklistDetails)
location = filter.getLocationName()
if location != "":
if filter.getLocationType() == "Country":
location = self.mdiParent.db.GetCountryName(location)
if filter.getLocationType() == "State":
location = self.mdiParent.db.GetStateName(location)
location = location + ": "
dateRange = self.lblDateRange.text()
family = filter.getFamily()
if family != "":
family = family.split(" (")[0]
family = " (" + family + ")"
order = filter.getOrder()
if order != "":
order = order + ":"
windowTitle = location + dateRange + order + family
self.setWindowTitle(windowTitle)
icon = QIcon()
icon.addPixmap(QPixmap(":/icon_bird.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.scaleMe()
self.resizeMe()
# tell MainWindow that we succeeded filling the list
return (True)
def genJobsTabTable(self):
self.jobsTabTable.setShowGrid(True)
self.jobsTabTable.setSortingEnabled(True)
self.jobsTabTable.setColumnCount(10)
self.jobsTabTable.setHorizontalHeaderLabels([
'Job', 'User', 'Status', 'Queue', 'Host', 'Processers', 'cpuTime',
'Span Hosts', 'Rusage (G)', 'Mem (G)'
])
command = 'bjobs -UF '
user = self.jobsTabUserLine.text().strip()
if re.match('^\s*$', user):
command = str(command) + ' -u all'
else:
command = str(command) + ' -u ' + str(user)
queue = self.jobsTabQueueCombo.currentText().strip()
if queue != 'ALL':
command = str(command) + ' -q ' + str(queue)
status = self.jobsTabStatusCombo.currentText().strip()
if status == 'RUN':
command = str(command) + ' -r'
elif status == 'PEND':
command = str(command) + ' -p'
elif status == 'ALL':
command = str(command) + ' -a'
startedOn = self.jobsTabStartedOnCombo.currentText().strip()
if startedOn != 'ALL':
command = str(command) + ' -m ' + str(startedOn)
jobDic = common.getBjobsUfInfo(command)
self.jobsTabTable.setRowCount(len(jobDic.keys()))
jobs = list(jobDic.keys())
for i in range(len(jobs)):
job = jobs[i]
j = 0
self.jobsTabTable.setItem(i, j, QTableWidgetItem(job))
j = j + 1
item = QTableWidgetItem()
item.setText(jobDic[job]['user'])
self.jobsTabTable.setItem(i, j, item)
j = j + 1
item = QTableWidgetItem()
item.setText(jobDic[job]['status'])
self.jobsTabTable.setItem(i, j, item)
j = j + 1
item = QTableWidgetItem()
item.setText(jobDic[job]['queue'])
self.jobsTabTable.setItem(i, j, item)
j = j + 1
item = QTableWidgetItem()
item.setText(jobDic[job]['startedOn'])
self.jobsTabTable.setItem(i, j, item)
j = j + 1
if str(jobDic[job]['processorsRequested']) != '':
item = QTableWidgetItem()
item.setData(Qt.DisplayRole,
int(jobDic[job]['processorsRequested']))
self.jobsTabTable.setItem(i, j, item)
j = j + 1
if str(jobDic[job]['cpuTime']) != '':
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(jobDic[job]['cpuTime']))
self.jobsTabTable.setItem(i, j, item)
j = j + 1
if str(jobDic[job]['spanHosts']) != '':
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, int(jobDic[job]['spanHosts']))
self.jobsTabTable.setItem(i, j, item)
j = j + 1
if str(jobDic[job]['rusageMem']) != '':
item = QTableWidgetItem()
rusageMemValue = int(jobDic[job]['rusageMem']) / 1024
item.setData(Qt.DisplayRole, int(rusageMemValue))
self.jobsTabTable.setItem(i, j, item)
j = j + 1
if str(jobDic[job]['mem']) != '':
item = QTableWidgetItem()
memValue = int(jobDic[job]['mem']) / 1024
item.setData(Qt.DisplayRole, int(memValue))
self.jobsTabTable.setItem(i, j, item)
