class DateDialog(QDialog):
def __init__(self, parent=None):
super(DateDialog, self).__init__(parent)
self.setWindowTitle("DateDialog")
layout = QVBoxLayout(self)
self.datetime = QDateTimeEdit(self)
self.datetime.setCalendarPopup(True)
self.datetime.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.datetime)
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
def dateTime(self):
return self.datetime.dateTime()
@staticmethod
def getDateTime(parent=None):
dialog = DateDialog(parent)
result = dialog.exec()
date = dialog.dateTime()
return date.date(), date.time(), result == QDialog.Accepted
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.datetime_1 = QDateTimeEdit(self) # 1
self.datetime_1.dateChanged.connect(lambda: print('Date Changed!'))
self.datetime_2 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 2
self.datetime_2.setDisplayFormat('yyyy-MM-dd HH:mm:ss')
self.datetime_2.timeChanged.connect(lambda: print('Time Changed!'))
print(self.datetime_2.date())
print(self.datetime_2.time())
print(self.datetime_2.dateTime())
self.datetime_3 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 3
self.datetime_3.dateTimeChanged.connect(lambda: print('DateTimeChanged!'))
self.datetime_3.setCalendarPopup(True)
self.datetime_4 = QDateTimeEdit(QDate.currentDate(), self) # 4
self.datetime_5 = QDateTimeEdit(QTime.currentTime(), self)
self.date = QDateEdit(QDate.currentDate(), self) # 5
self.date.setDisplayFormat('yyyy/MM/dd')
print(self.date.date())
self.time = QTimeEdit(QTime.currentTime(), self) # 6
self.time.setDisplayFormat('HH:mm:ss')
print(self.time.time())
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.datetime_1)
self.v_layout.addWidget(self.datetime_2)
self.v_layout.addWidget(self.datetime_3)
self.v_layout.addWidget(self.datetime_4)
self.v_layout.addWidget(self.datetime_5)
self.v_layout.addWidget(self.date)
self.v_layout.addWidget(self.time)
self.setLayout(self.v_layout)
class DateTimeEdit(WidgetWithTZinfo):
def __init__(self, parent=None):
super(DateTimeEdit, self).__init__(parent)
self.initQDateTimeEdit()
self.initTZinfoEdit()
def initQDateTimeEdit(self):
self.dateTimeEdit = QDateTimeEdit(self)
self.dateTimeEdit.setKeyboardTracking(False)
self.dateTimeEdit.setDisplayFormat("dd.MM.yyyy hh:mm:ss.zzz")
self.layout().addWidget(self.dateTimeEdit)
def dateTime(self) -> datetime.datetime:
dateTime = self.dateTimeEdit.dateTime().toPyDateTime()
tzinfo = self.tzinfoEdit.getObj2add()
dateTime = dateTime.replace(tzinfo=tzinfo)
return dateTime
def setDateTime(self, val: datetime.datetime):
if isinstance(val, datetime.datetime):
self.dateTimeEdit.setDateTime(val)
self.tzinfoEdit.setVal(val.tzinfo)
else:
raise TypeError("arg1 must be instance of type datetime.datetime:",
type(val))
class DateDialog(QDialog):
def __init__(self, parent=None):
super(DateDialog, self).__init__(parent)
layout = QVBoxLayout(self)
# nice widget for editing the date
self.datetime = QDateTimeEdit(self)
self.datetime.setCalendarPopup(True)
self.datetime.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.datetime)
# OK and Cancel buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# get current date and time from the dialog
def dateTime(self):
return self.datetime.dateTime()
# static method to create the dialog and return (date, time, accepted)
@staticmethod
def getDateTime(parent=None):
dialog = DateDialog(parent)
result = dialog.exec_()
date = dialog.dateTime()
return (date.date(), date.time(), result == QDialog.Accepted)
class DateTimeFilterPage(QWidget):
def __init__(self, parent=None):
super(DateTimeFilterPage, self).__init__(parent)
self.fromEdit = QDateTimeEdit()
self.toEdit = QDateTimeEdit()
groupLayout = QFormLayout()
groupLayout.addRow("Od:", self.fromEdit)
groupLayout.addRow("Do:", self.toEdit)
self.group = QGroupBox("Datum a čas")
self.group.setCheckable(True)
self.group.setChecked(False)
self.group.setLayout(groupLayout)
layout = QVBoxLayout()
layout.addWidget(self.group)
layout.addStretch(1)
self.setLayout(layout)
def initControls(self, filter_):
self.group.setChecked(False)
for key in ['start_datetime', 'end_datetime']:
if key in filter_:
self.group.setChecked(True)
break
start = filter_.get('start_datetime', datetime.utcnow())
start = calendar.timegm(start.timetuple())
end = filter_.get('end_datetime', datetime.utcnow())
end = calendar.timegm(end.timetuple())
self.fromEdit.setDateTime(QDateTime.fromTime_t(start, TZ))
self.toEdit.setDateTime(QDateTime.fromTime_t(end, TZ))
def getFilter(self):
filter_ = {}
if self.group.isChecked():
start = self.fromEdit.dateTime().toTime_t()
end = self.toEdit.dateTime().toTime_t()
filter_['start_datetime'] = datetime.utcfromtimestamp(start)
filter_['end_datetime'] = datetime.utcfromtimestamp(end)
return filter_
class DateTimeEditDemo(QWidget):
"""主窗口"""
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setWindowTitle("QDateTimeEdit 使用")
self.resize(320, 100)
date_time = QDateTime.currentDateTime()
self.datetime_edit = QDateTimeEdit(date_time) # 初始化时设置初始值为当前日期时间
# self.datetime_edit.setDateTime(date_time)
self.datetime_edit.setDisplayFormat("yyyy-MM-dd HH:mm:ss") # 设置显示格式
self.datetime_edit.setDateTimeRange(date_time.addYears(-1),
date_time.addYears(1)) # 设置时间范围
self.datetime_edit.setCalendarPopup(True) # 允许使用Calendar
self.datetime_edit.dateTimeChanged.connect(
self.datetime_change) # 会向槽函数传递QDateTime
self.datetime_edit.dateChanged.connect(
self.date_change) # 会向槽函数传递QDate
self.datetime_edit.timeChanged.connect(
self.time_change) # 会向槽函数传递QTime
self.button = QPushButton()
self.button.setText("获得日期和时间")
self.button.clicked.connect(self.btn_click)
self.status_bar = QStatusBar()
vbox = QVBoxLayout(self)
vbox.addWidget(self.datetime_edit)
vbox.addWidget(self.button)
vbox.addWidget(self.status_bar)
def datetime_change(self, date_time):
self.status_bar.showMessage(date_time.__str__())
def date_change(self, date):
self.status_bar.showMessage(date.__str__())
def time_change(self, time):
self.status_bar.showMessage(time.__str__())
def btn_click(self, event):
date_time = self.datetime_edit.dateTime()
max_date_time = self.datetime_edit.maximumDateTime()
max_date = self.datetime_edit.maximumDate()
max_time = self.datetime_edit.maximumTime()
min_date_time = self.datetime_edit.minimumDateTime()
min_date = self.datetime_edit.minimumDate()
min_time = self.datetime_edit.minimumTime()
format_str = f"max_date_time: {max_date_time}\nmax_date: {max_date}\nmax_time: {max_time}\n\
min_date_time: {min_date_time}\nmin_time: {min_time}\nmin_time: {min_time}\n{event}"
_ = QMessageBox.information(self, "显示QDateTime中的一些数据", format_str)
class MainWin(QWidget):
def __init__(self, parent=None):
super(MainWin, self).__init__(parent)
layout = QVBoxLayout(self)
self.dateEdit = QDateTimeEdit(QDateTime.currentDateTime(), self)
self.dateEdit.setDisplayFormat('yyyy-MM-dd HH:mm:ss')
self.dateEdit.setMinimumDate(QDate.currentDate().addDays(-365))
self.dateEdit.setMaximumDate(QDate.currentDate().addDays(365))
self.dateEdit.setCalendarPopup(True)
self.dateEdit.dateChanged.connect(self.onDateChanged)
self.dateEdit.dateTimeChanged.connect(self.onDateTimeChanged)
self.dateEdit.timeChanged.connect(self.onTimeChanged)
self.btn = QPushButton('取得日期和時間')
self.btn.clicked.connect(self.onButtonClick)
layout.addWidget(self.dateEdit)
layout.addWidget(self.btn)
self.resize(300, 90)
self.setWindowTitle('DateTimeEdit2')
def onDateChanged(self, date):
print(date)
def onDateTimeChanged(self, dateTime):
print(dateTime)
def onTimeChanged(self, time):
print(time)
def onButtonClick(self):
dateTime = self.dateEdit.dateTime()
maxDate = self.dateEdit.maximumDate()
maxDateTime = self.dateEdit.maximumDateTime()
maxTime = self.dateEdit.maximumTime()
minDate = self.dateEdit.minimumDate()
minDateTime = self.dateEdit.minimumDateTime()
minTime = self.dateEdit.minimumTime()
print('\n選擇的日期時間')
print('dateTime = %s')
print('maxDate = %s' % str(maxDate))
print('maxDateTime = %s' % str(maxDateTime))
print('maxTime = %s' % str(maxTime))
print('minDate = %s' % str(minDate))
print('minDateTime = %s' % str(minDateTime))
print('minTime = %s' % str(minTime))
def group_datetime_spinbox(self):
group2 = QGroupBox('QDateTimeEdit')
lbl = QLabel('QDateTimeEdit')
date_time_edit = QDateTimeEdit(self)
date_time_edit.setDateTime(QDateTime.currentDateTime())
date_time_edit.setDateTimeRange(QDateTime(1900, 1, 1, 00, 00, 00),
QDateTime(2100, 1, 1, 00, 00, 00))
date_time_edit.setDisplayFormat('yyyy-MM-dd hh:mm:ss')
date_time_edit.dateTimeChanged.connect(self.datetime_value_change)
self.lbl5 = QLabel(
date_time_edit.dateTime().toString('yyyy-MM-dd hh:mm:ss'))
layout_group5 = QHBoxLayout()
layout_group5.addWidget(lbl)
layout_group5.addWidget(date_time_edit)
layout_group5.addWidget(self.lbl5)
return layout_group5
class Scheduler(QDialog):
def __init__(self, photo, caption, ig):
super(Scheduler, self).__init__()
self.photo = photo
self.caption = caption
self.ig = ig
self.init_ui()
self.exec_()
def init_ui(self):
self.setWindowTitle("Schedule Post")
self.date_edit = QDateTimeEdit(QDateTime.currentDateTime())
self.date_edit.setDisplayFormat("dd.MM.yyyy hh:mm")
self.date_edit.setMinimumDateTime(QDateTime.currentDateTime())
self.calendar = QCalendarWidget(self)
self.calendar.setGridVisible(True)
self.calendar.setMinimumDate(QDate.currentDate())
self.calendar.setSelectedDate(QDate.currentDate())
self.calendar.clicked.connect(self.set_date_time)
self.confirm_button = QPushButton("Confirm")
self.confirm_button.clicked.connect(self.set_schedule)
vbox = QVBoxLayout(self)
vbox.addWidget(self.date_edit)
vbox.addWidget(self.calendar)
vbox.addWidget(self.confirm_button)
def set_date_time(self, qDate):
self.date_edit.setDate(qDate)
def set_schedule(self):
self.date_time = self.date_edit.dateTime()
schedule = self.date_time.toPyDateTime()
now = datetime.now()
delta_t = schedule - now
secs = delta_t.seconds + 1
t = Timer(secs, self.ig.upload, [self.photo, self.caption])
t.start()
self.accept()
class NewBreakageDialog(QDialog):
def __init__(self):
super().__init__()
self.is_accepted = False
self.setWindowTitle("Новая поломка")
self.setLayout(QFormLayout())
self.place_field = QLineEdit()
self.layout().addRow("Место", self.place_field)
self.time_field = QDateTimeEdit()
self.time_field.setMaximumDateTime(datetime.now())
self.layout().addRow("Время", self.time_field)
self.description_field = QTextEdit()
self.layout().addRow("Описание", self.description_field)
accept_button = QPushButton("Ок")
accept_button.clicked.connect(self.confirm)
self.layout().addRow("Принять", accept_button)
def confirm(self):
if len(self.place) > 0 or len(self.description) > 0:
self.is_accepted = True
self.close()
@property
def place(self):
return self.place_field.text()
@property
def time(self):
return self.time_field.dateTime().toSecsSinceEpoch()
@property
def description(self):
return self.description_field.toPlainText()
class DateDialog(QDialog):
def __init__(self, parent=None):
super(DateDialog, self).__init__(parent)
layout = QVBoxLayout(self)
# info text
self.label = QLabel(
text='The file appears to contain relative dates.\n'
'Please specify a reference date.')
layout.addWidget(self.label)
# nice widget for editing the date
self.datetime = QDateTimeEdit(self)
self.datetime.setCalendarPopup(True)
self.datetime.setDisplayFormat('yyyy-MM-dd hh:mm:ss')
self.datetime.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.datetime)
# OK and Cancel buttons
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
layout.addWidget(self.buttons)
self.setLayout(layout)
# get current date and time from the dialog
def date_time(self):
return self.datetime.dateTime()
# static method to create the dialog and return (date, time, accepted)
@staticmethod
def get_date_time(parent=None):
dialog = DateDialog(parent)
result = dialog.exec_()
date = dialog.date_time()
return date.toPyDateTime(), result == QDialog.Accepted
class DatetimeEditField(DataEditField):
"""
Class for editing datetime fields.
"""
def __init__(self, parent, title, help_text):
self.field = QDateTimeEdit(datetime.now())
self.field.setCalendarPopup(True)
self.field.setDisplayFormat("dd-MM-yyyy hh:mm:ss")
DataEditField.__init__(self, parent, title, help_text, self.field)
def clearField(self):
"""
Set field to current datetime
"""
self.field.setDateTime(datetime.now())
def getValue(self):
"""
Get value of DateTimeEditField
"""
return qDateTime2Datetime(self.field.dateTime())
class DateDialog(QDialog):
def __init__(self, parent=None):
super(DateDialog, self).__init__(parent)
layout = QVBoxLayout(self)
# nice widget for editing the date
self.datetime = QDateTimeEdit(self)
self.datetime.setCalendarPopup(True)
self.datetime.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.datetime)
# OK and Cancel buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# get current date and time from the dialog
def dateTime(self):
return self.datetime.dateTime()
class NewDateDialog(QDialog):
Signal_OneParameter = pyqtSignal(str)
def __init__(self, parent=None):
super(NewDateDialog, self).__init__(parent)
self.setWindowTitle('子窗口：用来发射信号')
# 在布局中添加部件
layout = QVBoxLayout(self)
self.label = QLabel(self)
self.label.setText('前者发射内置信号\n后者发射自定义信号')
self.datetime_inner = QDateTimeEdit(self)
self.datetime_inner.setCalendarPopup(True)
self.datetime_inner.setDateTime(QDateTime.currentDateTime())
self.datetime_emit = QDateTimeEdit(self)
self.datetime_emit.setCalendarPopup(True)
self.datetime_emit.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.label)
layout.addWidget(self.datetime_inner)
layout.addWidget(self.datetime_emit)
# 使用两个button(ok和cancel)分别连接accept()和reject()槽函数
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
self.datetime_emit.dateTimeChanged.connect(self.emit_signal)
def emit_signal(self):
date_str = self.datetime_emit.dateTime().toString()
self.Signal_OneParameter.emit(date_str)
class DateDialog(QDialog):
"""对话窗口"""
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setWindowTitle("多窗口利用控件属性传递参数")
self.resize(200, 100)
self.datetimedit = QDateTimeEdit(parent=self)
self.datetimedit.setCalendarPopup(True)
self.datetimedit.setMinimumSize(100, 20)
self.datetimedit.setDateTime(QDateTime.currentDateTime())
buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel,
Qt.Horizontal,
parent=self)
# 两个按钮, 分别连接dialog.accept()和dialog.reject()
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
v_layout = QVBoxLayout()
v_layout.addWidget(self.datetimedit)
v_layout.addWidget(buttons)
self.setLayout(v_layout)
def date_time(self):
"""从对话框中获取当前日期和时间"""
return self.datetimedit.dateTime()
@staticmethod
def get_date_time(parent=None):
"""静态方法, 创建一个自己, 返回时间"""
dialog = DateDialog(parent)
result = dialog.exec()
date = dialog.date_time()
return date.date(), date.time(), result == QDialog.Accepted
class QtDBConsoleWindow(QMainWindow):
def __init__(self, master):
super(QtDBConsoleWindow, self).__init__()
self.master = master
self.connection = self.master.connection
self.GroupBoxSeg = [1, 10, 1]
self.processing = []
#Fixme: QTimer to be added to update the page automatically
self.mainWidget = QWidget()
self.mainLayout = QGridLayout()
self.mainWidget.setLayout(self.mainLayout)
self.setCentralWidget(self.mainWidget)
self.occupied()
self.setLoginUI()
self.createHeadLine()
self.createMain()
self.createApp()
if isActive(self.connection):
self.connectDB()
def setLoginUI(self):
self.setGeometry(200, 200, 600, 1200)
self.setWindowTitle('Database Console')
self.menubar = self.menuBar()
self.menubar.setNativeMenuBar(False)
###################################################
## Database Menu
###################################################
self.actionDatabase = self.menubar.addMenu("&Database")
self.ViewerAction = QAction("&View Table")
self.ViewerAction.triggered.connect(self.viewTable)
self.actionDatabase.addAction(self.ViewerAction)
###################################################
## Image Menu
###################################################
self.actionImage = self.menubar.addMenu("&Image")
self.InsertImgAction = QAction("&Insert Image")
self.InsertImgAction.triggered.connect(self.insertImage)
self.actionImage.addAction(self.InsertImgAction)
self.ViewImgAction = QAction("&View Image")
self.ViewImgAction.triggered.connect(self.viewImage)
self.actionImage.addAction(self.ViewImgAction)
###################################################
## Shipment Menu
###################################################
self.actionShipment = self.menubar.addMenu("&Shipment")
self.sendPackAction = QAction("&Send Package")
self.sendPackAction.triggered.connect(self.sendPackage)
self.actionShipment.addAction(self.sendPackAction)
self.receivePackAction = QAction("&Receive Package")
self.receivePackAction.triggered.connect(self.receivePackage)
self.actionShipment.addAction(self.receivePackAction)
###################################################
## User Menu
###################################################
self.actionUser = self.menubar.addMenu("&User")
self.ShowUserAction = QAction("&Show Users", self)
self.ShowUserAction.triggered.connect(self.displayUsers)
self.actionUser.addAction(self.ShowUserAction)
self.AddUserAction = QAction("&Add Users", self)
self.AddUserAction.triggered.connect(self.addUsers)
self.actionUser.addAction(self.AddUserAction)
self.UpdateUserAction = QAction("&Update Profile", self)
self.UpdateUserAction.triggered.connect(self.updateProfile)
self.actionUser.addAction(self.UpdateUserAction)
self.ShowInstAction = QAction("&Show institute", self)
self.ShowInstAction.triggered.connect(self.displayInstitue)
self.actionUser.addAction(self.ShowInstAction)
###################################################
## Miscellanea Menu
###################################################
self.actionMiscel = self.menubar.addMenu("&Miscellanea")
self.ComplaintAction = QAction("&Submit Complaint", self)
self.ComplaintAction.triggered.connect(self.fileComplaint)
self.actionMiscel.addAction(self.ComplaintAction)
self.show()
def activateMenuBar(self):
self.menubar.setDisabled(False)
def deactivateMenuBar(self):
self.menubar.setDisabled(True)
def enableMenuItem(self, item, enabled):
item.setEnabled(enabled)
##########################################################################
## Functions for Table Viewer
##########################################################################
def viewTable(self):
viewTableTab = QtViewTableTab(self)
self.MainTabs.addTab(viewTableTab, "Database Viewer")
self.MainTabs.setCurrentWidget(viewTableTab)
##########################################################################
## Functions for Table Viewer (END)
##########################################################################
##########################################################################
## Functions for Image
##########################################################################
def insertImage(self):
insertImageTab = QtImageInsertionTab(self)
self.InsertImgAction.setDisabled(True)
self.MainTabs.addTab(insertImageTab, "Insert Image")
self.MainTabs.setCurrentWidget(insertImageTab)
def viewImage(self):
viewImageTab = QtImageViewerTab(self)
self.MainTabs.addTab(viewImageTab, "Image Viewer")
self.MainTabs.setCurrentWidget(viewImageTab)
##########################################################################
## Functions for Image (END)
##########################################################################
##########################################################################
## Functions for Shipment
##########################################################################
def sendPackage(self):
self.sendPackageTab = QWidget()
# Add tabs
self.MainTabs.addTab(self.sendPackageTab, "Send Package")
self.sendPackAction.setDisabled(True)
self.sendPackageTab.layout = QGridLayout(self)
sendPackageLabel = QLabel('<font size="12"> Package Delivery </font>')
sendPackageLabel.setMaximumHeight(60)
self.SPSenderLabel = QLabel('Sender:')
self.SPSenderEdit = QLineEdit('')
self.SPSenderEdit.setEchoMode(QLineEdit.Normal)
self.SPSenderEdit.setPlaceholderText('Sender Name')
self.SPReceiverLabel = QLabel('Receiver:')
self.SPReceiverEdit = QLineEdit('')
self.SPReceiverEdit.setEchoMode(QLineEdit.Normal)
self.SPReceiverEdit.setPlaceholderText('Receiver Name')
self.SPReceiverEdit.setDisabled(True)
siteList = getByColumnName("institute",
describeInstitute(self.connection),
retrieveAllInstitute(self.connection))
self.SPOriginLabel = QLabel('Origin:')
self.SPOriginCombo = QComboBox()
self.SPOriginCombo.addItems(["{0}".format(x) for x in siteList])
self.SPDestinationLabel = QLabel('Destination:')
self.SPDestinationCombo = QComboBox()
self.SPDestinationCombo.addItems(["{0}".format(x) for x in siteList])
self.SPDateSentLabel = QLabel('date sent:')
self.SPDateSentEdit = QDateTimeEdit()
self.SPDateSentEdit.setDateTime(QDateTime.currentDateTime())
self.SPDateReceivedLabel = QLabel('date received:')
self.SPDateReceivedEdit = QDateTimeEdit()
self.SPDateReceivedEdit.setDisabled(True)
#self.SPDateReceivedEdit.setDateTime(QDateTime.currentDateTime())
self.SPCarrierLabel = QLabel('Carrier:')
self.SPCarrierEdit = QLineEdit('')
self.SPCarrierEdit.setEchoMode(QLineEdit.Normal)
self.SPCarrierEdit.setPlaceholderText('carrier name')
self.SPTrackingLabel = QLabel('Tracking Number:')
self.SPTrackingEdit = QLineEdit('')
self.SPTrackingEdit.setEchoMode(QLineEdit.Normal)
self.SPTrackingEdit.setPlaceholderText('Tracking Code')
self.SPCommentLabel = QLabel('Comment:')
self.SPCommentEdit = QTextEdit('')
self.SPCommentEdit.setPlaceholderText("Your comment")
self.SPFeedBackLabel = QLabel()
self.SPSubmitButton = QPushButton('Submit')
self.SPSubmitButton.clicked.connect(self.submitSPRequest)
self.sendPackageTab.layout.addWidget(sendPackageLabel, 0, 0, 1, 4,
Qt.AlignTop)
self.sendPackageTab.layout.addWidget(self.SPSenderLabel, 1, 0, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPSenderEdit, 1, 1, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPDateSentLabel, 1, 2, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPDateSentEdit, 1, 3, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPOriginLabel, 2, 0, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPOriginCombo, 2, 1, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPDestinationLabel, 2, 2, 1,
1)
self.sendPackageTab.layout.addWidget(self.SPDestinationCombo, 2, 3, 1,
1)
self.sendPackageTab.layout.addWidget(self.SPCarrierLabel, 3, 0, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPCarrierEdit, 3, 1, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPTrackingLabel, 3, 2, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPTrackingEdit, 3, 3, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPCommentLabel, 4, 0, 1, 4,
Qt.AlignLeft)
self.sendPackageTab.layout.addWidget(self.SPCommentEdit, 5, 0, 3, 4)
self.sendPackageTab.layout.addWidget(self.SPFeedBackLabel, 8, 0, 1, 2)
self.sendPackageTab.layout.addWidget(self.SPSubmitButton, 8, 3, 1, 1)
self.sendPackageTab.setLayout(self.sendPackageTab.layout)
self.MainTabs.setCurrentWidget(self.sendPackageTab)
def submitSPRequest(self):
if self.SPTrackingEdit.text() == "":
self.SPFeedBackLabel.setText(
"Please make sure Tracking Number are filled")
return
if self.SPSenderEdit.text() == "":
self.SPFeedBackLabel.setText("Please make sure sender are filled")
return
Args = describeTable(self.connection, "shipment")
Data = []
SubmitArgs = []
for arg in Args:
if arg == "origin":
Data.append(self.SPOriginCombo.currentText())
SubmitArgs.append(arg)
if arg == "destination":
Data.append(self.SPDestinationCombo.currentText())
SubmitArgs.append(arg)
if arg == "sender":
Data.append(self.SPSenderEdit.text())
SubmitArgs.append(arg)
if arg == "date_sent":
Data.append(self.SPDateSentEdit.dateTime().toUTC().toString(
"yyyy-dd-MM hh:mm:ss.z"))
SubmitArgs.append(arg)
if arg == "carrier":
Data.append(self.SPCarrierEdit.text())
SubmitArgs.append(arg)
if arg == "tracking_number":
Data.append(self.SPTrackingEdit.text())
SubmitArgs.append(arg)
if arg == "comment":
Data.append(self.SPCommentEdit.toPlainText())
SubmitArgs.append(arg)
try:
insertGenericTable(self.connection, "shipment", SubmitArgs, Data)
except:
print("Failed to submit the shipment record")
return
self.SPSenderLabel.deleteLater()
self.SPSenderEdit.deleteLater()
self.SPDateSentLabel.deleteLater()
self.SPDateSentEdit.deleteLater()
self.SPOriginLabel.deleteLater()
self.SPOriginCombo.deleteLater()
self.SPDestinationLabel.deleteLater()
self.SPDestinationCombo.deleteLater()
self.SPCarrierLabel.deleteLater()
self.SPCarrierEdit.deleteLater()
self.SPTrackingLabel.deleteLater()
self.SPTrackingEdit.deleteLater()
self.SPCommentLabel.deleteLater()
self.SPCommentEdit.deleteLater()
self.SPFeedBackLabel.deleteLater()
self.SPSubmitButton.deleteLater()
self.sendPackageTab.layout.removeWidget(self.SPSenderLabel)
self.sendPackageTab.layout.removeWidget(self.SPSenderEdit)
self.sendPackageTab.layout.removeWidget(self.SPDateSentLabel)
self.sendPackageTab.layout.removeWidget(self.SPDateSentEdit)
self.sendPackageTab.layout.removeWidget(self.SPOriginLabel)
self.sendPackageTab.layout.removeWidget(self.SPOriginCombo)
#self.sendPackageTab.layout.removeWidget(self.SPDestinationLabel)
#self.sendPackageTab.layout.removeWidget(self.SPDestinationCombo)
self.sendPackageTab.layout.removeWidget(self.SPCarrierLabel)
self.sendPackageTab.layout.removeWidget(self.SPCarrierEdit)
self.sendPackageTab.layout.removeWidget(self.SPTrackingLabel)
self.sendPackageTab.layout.removeWidget(self.SPTrackingEdit)
self.sendPackageTab.layout.removeWidget(self.SPCommentLabel)
self.sendPackageTab.layout.removeWidget(self.SPCommentEdit)
self.sendPackageTab.layout.removeWidget(self.SPFeedBackLabel)
self.sendPackageTab.layout.removeWidget(self.SPSubmitButton)
self.SPFeedBackLabel = QLabel("Submitted")
self.SPFeedBackLabel.setStyleSheet("color:green")
self.SPContinueButton = QPushButton('Continue')
self.SPContinueButton.clicked.connect(self.recreateSP)
self.SPCloseButton = QPushButton('Close')
self.SPCloseButton.clicked.connect(self.closeSP)
self.sendPackageTab.layout.addWidget(self.SPFeedBackLabel, 1, 0, 1, 2)
self.sendPackageTab.layout.addWidget(self.SPContinueButton, 1, 3, 1, 1)
self.sendPackageTab.layout.addWidget(self.SPCloseButton, 1, 4, 1, 1)
return
def recreateSP(self):
self.closeTab(self.MainTabs.currentIndex())
self.sendPackage()
def closeSP(self):
self.closeTab(self.MainTabs.currentIndex())
def receivePackage(self):
self.receivePackageTab = QWidget()
# Add tabs
self.MainTabs.addTab(self.receivePackageTab, "Receive Package")
self.receivePackAction.setDisabled(True)
self.receivePackageTab.layout = QGridLayout(self)
receivePackageLabel = QLabel(
'<font size="12"> Package Delivery </font>')
receivePackageLabel.setMaximumHeight(60)
self.RPIDLabel = QLabel('ID:')
self.RPIDEdit = QLineEdit('')
self.RPIDEdit.setEchoMode(QLineEdit.Normal)
self.RPIDEdit.setPlaceholderText('Shipment ID')
self.RPFetchButton = QPushButton("Fetch")
self.RPFetchButton.clicked.connect(self.fillRPRequest)
self.RPSenderLabel = QLabel('Sender:')
self.RPSenderEdit = QLineEdit('')
self.RPSenderEdit.setEchoMode(QLineEdit.Normal)
self.RPSenderEdit.setPlaceholderText('Sender Name')
self.RPSenderEdit.setDisabled(True)
self.RPReceiverLabel = QLabel('Receiver:')
self.RPReceiverEdit = QLineEdit('')
self.RPReceiverEdit.setEchoMode(QLineEdit.Normal)
self.RPReceiverEdit.setPlaceholderText('Receiver Name')
siteList = getByColumnName("institute",
describeInstitute(self.connection),
retrieveAllInstitute(self.connection))
self.RPOriginLabel = QLabel('Origin:')
self.RPOriginCombo = QComboBox()
self.RPOriginCombo.addItems(["{0}".format(x) for x in siteList])
self.RPOriginCombo.setDisabled(True)
self.RPDestinationLabel = QLabel('Destination:')
self.RPDestinationCombo = QComboBox()
self.RPDestinationCombo.addItems(["{0}".format(x) for x in siteList])
self.RPDestinationCombo.setDisabled(True)
self.RPDateSentLabel = QLabel('date sent:')
self.RPDateSentEdit = QDateTimeEdit()
#self.RPDateSentEdit.setDateTime(QDateTime.currentDateTime())
self.RPDateSentEdit.setDisabled(True)
self.RPDateReceivedLabel = QLabel('date received:')
self.RPDateReceivedEdit = QDateTimeEdit()
self.RPDateReceivedEdit.setDateTime(QDateTime.currentDateTime())
self.RPCarrierLabel = QLabel('Carrier:')
self.RPCarrierEdit = QLineEdit('')
self.RPCarrierEdit.setEchoMode(QLineEdit.Normal)
self.RPCarrierEdit.setPlaceholderText('carrier name')
self.RPCarrierEdit.setDisabled(True)
self.RPTrackingLabel = QLabel('Tracking Number:')
self.RPTrackingEdit = QLineEdit('')
self.RPTrackingEdit.setEchoMode(QLineEdit.Normal)
self.RPTrackingEdit.setPlaceholderText('Tracking Code')
self.RPTrackingEdit.setDisabled(True)
self.RPCommentLabel = QLabel('Comment:')
self.RPCommentEdit = QTextEdit('')
self.RPCommentEdit.setPlaceholderText("Your comment")
self.RPFeedBackLabel = QLabel()
self.RPSubmitButton = QPushButton('Submit')
self.RPSubmitButton.clicked.connect(self.submitRPRequest)
self.receivePackageTab.layout.addWidget(receivePackageLabel, 0, 0, 1,
4, Qt.AlignTop)
self.receivePackageTab.layout.addWidget(self.RPIDLabel, 1, 0, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPIDEdit, 1, 1, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPFetchButton, 1, 2, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPSenderLabel, 2, 0, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPSenderEdit, 2, 1, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPDateSentLabel, 2, 2, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPDateSentEdit, 2, 3, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPReceiverLabel, 3, 0, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPReceiverEdit, 3, 1, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPDateReceivedLabel, 3, 2,
1, 1)
self.receivePackageTab.layout.addWidget(self.RPDateReceivedEdit, 3, 3,
1, 1)
self.receivePackageTab.layout.addWidget(self.RPOriginLabel, 4, 0, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPOriginCombo, 4, 1, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPDestinationLabel, 4, 2,
1, 1)
self.receivePackageTab.layout.addWidget(self.RPDestinationCombo, 4, 3,
1, 1)
self.receivePackageTab.layout.addWidget(self.RPCarrierLabel, 5, 0, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPCarrierEdit, 5, 1, 1, 1)
self.receivePackageTab.layout.addWidget(self.RPTrackingLabel, 5, 2, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPTrackingEdit, 5, 3, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPCommentLabel, 6, 0, 1,
4, Qt.AlignLeft)
self.receivePackageTab.layout.addWidget(self.RPCommentEdit, 7, 0, 3, 4)
self.receivePackageTab.layout.addWidget(self.RPFeedBackLabel, 10, 0, 1,
3)
self.receivePackageTab.layout.addWidget(self.RPSubmitButton, 10, 3, 1,
1)
self.receivePackageTab.setLayout(self.receivePackageTab.layout)
self.MainTabs.setCurrentWidget(self.receivePackageTab)
def fillRPRequest(self):
try:
header = describeTable(self.connection, "shipment", True)
shipmentInfo = retrieveWithConstraint(self.connection,
"shipment",
id=self.RPIDEdit.text())
except:
return
if len(shipmentInfo) > 0 and len(header) == len(shipmentInfo[0]):
self.RPFeedBackLabel.setText("Delivery Record found")
self.RPSenderEdit.setText(
getByColumnName("sender", header, shipmentInfo)[0])
origin_index = self.RPOriginCombo.findText(
getByColumnName("origin", header, shipmentInfo)[0])
self.RPOriginCombo.setCurrentIndex(origin_index)
destination_index = self.RPDestinationCombo.findText(
getByColumnName("destination", header, shipmentInfo)[0])
self.RPDestinationCombo.setCurrentIndex(destination_index)
time_string = getByColumnName(
"date_sent", header,
shipmentInfo)[0].strftime("%m/%d/%Y, %H:%M:%S")
print(time_string)
self.RPDateSentEdit.setDateTime(QDateTime.fromString(time_string))
self.RPCarrierEdit.setText(
getByColumnName("carrier", header, shipmentInfo)[0])
self.RPTrackingEdit.setText(
getByColumnName("tracking_number", header, shipmentInfo)[0])
self.RPCommentEdit.setText(
getByColumnName("comment", header, shipmentInfo)[0])
else:
self.RPFeedBackLabel.setText("Shipment ID not found")
self.RPSenderEdit.setText("")
origin_index = self.RPOriginCombo.findText("")
self.RPOriginCombo.setCurrentIndex(origin_index)
destination_index = self.RPDestinationCombo.findText("")
self.RPDestinationCombo.setCurrentIndex(destination_index)
#time_string = datetime.strftime("%m/%d/%Y, %H:%M:%S")
#self.RPDateSentEdit.setDateTime(QDateTime.fromString(time_string))
self.RPCarrierEdit.setText("")
self.RPTrackingEdit.setText("")
self.RPCommentEdit.setText("")
def submitRPRequest(self):
if self.RPTrackingEdit.text() == "":
self.RPFeedBackLabel.setText(
"Please make sure Tracking Number are filled")
return
if self.RPReceiverEdit.text() == "":
self.RPFeedBackLabel.setText(
"Please make sure receiver are filled")
return
if self.RPDateReceivedEdit.text() == "":
self.RPFeedBackLabel.setText(
"Please make sure received time are filled")
return
Args = describeTable(self.connection, "shipment")
Data = []
SubmitArgs = []
for arg in Args:
if arg == "receiver":
Data.append(self.RPReceiverEdit.text())
SubmitArgs.append(arg)
if arg == "date_received":
Data.append(
self.RPDateReceivedEdit.dateTime().toUTC().toString(
"yyyy-dd-MM hh:mm:ss.z"))
SubmitArgs.append(arg)
if arg == "comment":
Data.append(self.RPCommentEdit.toPlainText())
SubmitArgs.append(arg)
try:
updateGenericTable(self.connection,
"shipment",
SubmitArgs,
Data,
id=int(self.RPIDEdit.text()))
except:
print("Failed to submit the shipment record")
return
self.RPIDLabel.deleteLater()
self.RPIDEdit.deleteLater()
self.RPFetchButton.deleteLater()
self.RPSenderLabel.deleteLater()
self.RPSenderEdit.deleteLater()
self.RPDateSentLabel.deleteLater()
self.RPDateSentEdit.deleteLater()
self.RPReceiverLabel.deleteLater()
self.RPReceiverEdit.deleteLater()
self.RPDateReceivedLabel.deleteLater()
self.RPDateReceivedEdit.deleteLater()
self.RPOriginLabel.deleteLater()
self.RPOriginCombo.deleteLater()
self.RPDestinationLabel.deleteLater()
self.RPDestinationCombo.deleteLater()
self.RPCarrierLabel.deleteLater()
self.RPCarrierEdit.deleteLater()
self.RPTrackingLabel.deleteLater()
self.RPTrackingEdit.deleteLater()
self.RPCommentLabel.deleteLater()
self.RPCommentEdit.deleteLater()
self.RPFeedBackLabel.deleteLater()
self.RPSubmitButton.deleteLater()
self.receivePackageTab.layout.removeWidget(self.RPIDEdit)
self.receivePackageTab.layout.removeWidget(self.RPIDLabel)
self.receivePackageTab.layout.removeWidget(self.RPFetchButton)
self.receivePackageTab.layout.removeWidget(self.RPSenderLabel)
self.receivePackageTab.layout.removeWidget(self.RPSenderEdit)
self.receivePackageTab.layout.removeWidget(self.RPDateSentLabel)
self.receivePackageTab.layout.removeWidget(self.RPDateSentEdit)
self.receivePackageTab.layout.removeWidget(self.RPReceiverLabel)
self.receivePackageTab.layout.removeWidget(self.RPReceiverEdit)
self.receivePackageTab.layout.removeWidget(self.RPDateReceivedLabel)
self.receivePackageTab.layout.removeWidget(self.RPDateReceivedEdit)
self.receivePackageTab.layout.removeWidget(self.RPOriginLabel)
self.receivePackageTab.layout.removeWidget(self.RPOriginCombo)
self.receivePackageTab.layout.removeWidget(self.RPDestinationLabel)
self.receivePackageTab.layout.removeWidget(self.RPDestinationCombo)
self.receivePackageTab.layout.removeWidget(self.RPCarrierLabel)
self.receivePackageTab.layout.removeWidget(self.RPCarrierEdit)
self.receivePackageTab.layout.removeWidget(self.RPTrackingLabel)
self.receivePackageTab.layout.removeWidget(self.RPTrackingEdit)
self.receivePackageTab.layout.removeWidget(self.RPCommentLabel)
self.receivePackageTab.layout.removeWidget(self.RPCommentEdit)
self.receivePackageTab.layout.removeWidget(self.RPFeedBackLabel)
self.receivePackageTab.layout.removeWidget(self.RPSubmitButton)
self.RPFeedBackLabel = QLabel("Submitted")
self.RPFeedBackLabel.setStyleSheet("color:green")
self.RPContinueButton = QPushButton('Continue')
self.RPContinueButton.clicked.connect(self.recreateRP)
self.RPCloseButton = QPushButton('Close')
self.RPCloseButton.clicked.connect(self.closeRP)
self.receivePackageTab.layout.addWidget(self.RPFeedBackLabel, 1, 0, 1,
2)
self.receivePackageTab.layout.addWidget(self.RPContinueButton, 1, 3, 1,
1)
self.receivePackageTab.layout.addWidget(self.RPCloseButton, 1, 4, 1, 1)
return
def recreateRP(self):
self.closeTab(self.MainTabs.currentIndex())
self.receivePackage()
def closeRP(self):
self.closeTab(self.MainTabs.currentIndex())
##########################################################################
## Functions for Shipment (END)
##########################################################################
def displayUsers(self):
self.processing.append("UserDisplay")
UserDisplayTab = QWidget()
# Add tabs
self.MainTabs.addTab(UserDisplayTab, "User List")
UserDisplayTab.layout = QGridLayout()
dataList = ([describeTable(self.connection, "people")] +
retrieveGenericTable(self.connection, "people"))
proxy = QtDBTableWidget(dataList, 0)
lineEdit = QLineEdit()
lineEdit.textChanged.connect(proxy.on_lineEdit_textChanged)
view = QTableView()
view.setSortingEnabled(True)
comboBox = QComboBox()
comboBox.addItems(["{0}".format(x) for x in dataList[0]])
comboBox.currentIndexChanged.connect(
proxy.on_comboBox_currentIndexChanged)
label = QLabel()
label.setText("Regex Filter")
view.setModel(proxy)
view.setSelectionBehavior(QAbstractItemView.SelectRows)
view.setSelectionMode(QAbstractItemView.MultiSelection)
view.setEditTriggers(QAbstractItemView.NoEditTriggers)
UserDisplayTab.layout.addWidget(lineEdit, 0, 1, 1, 1)
UserDisplayTab.layout.addWidget(view, 1, 0, 1, 3)
UserDisplayTab.layout.addWidget(comboBox, 0, 2, 1, 1)
UserDisplayTab.layout.addWidget(label, 0, 0, 1, 1)
UserDisplayTab.setLayout(UserDisplayTab.layout)
self.MainTabs.setCurrentWidget(UserDisplayTab)
##########################################################################
## Functions for Managing Users
##########################################################################
def addUsers(self):
## Fixme: disable the menu when tab exists, relieaze the menu when closed.
self.processing.append("AddUser")
AddingUserTab = QWidget()
# Add tabs
self.MainTabs.addTab(AddingUserTab, "Adding User")
self.AddUserAction.setDisabled(True)
AddingUserTab.layout = QGridLayout(self)
AddUserLabel = QLabel('<font size="12"> Creating new user: </font>')
AddUserLabel.setMaximumHeight(60)
self.AUNewUsernameLabel = QLabel('username')
self.AUNewUsernameEdit = QLineEdit('')
self.AUNewUsernameEdit.setEchoMode(QLineEdit.Normal)
self.AUNewUsernameEdit.setPlaceholderText('new username')
self.AUPasswordLabel = QLabel('password')
self.AUPasswordEdit = QLineEdit('')
self.AUPasswordEdit.setEchoMode(QLineEdit.Password)
self.AUPasswordEdit.setPlaceholderText('new password')
self.AURePasswordLabel = QLabel('re-password')
self.AURePasswordEdit = QLineEdit('')
self.AURePasswordEdit.setEchoMode(QLineEdit.Password)
self.AURePasswordEdit.setPlaceholderText('verify password')
self.AUNameLabel = QLabel('*name')
self.AUNameEdit = QLineEdit('')
self.AUNameEdit.setEchoMode(QLineEdit.Normal)
self.AUNameEdit.setPlaceholderText('short name')
self.AUFullNameLabel = QLabel('*full name')
self.AUFullNameEdit = QLineEdit('')
self.AUFullNameEdit.setEchoMode(QLineEdit.Normal)
self.AUFullNameEdit.setPlaceholderText('full name')
self.AUEmailLabel = QLabel('e-mail')
self.AUEmailEdit = QLineEdit('')
self.AUEmailEdit.setEchoMode(QLineEdit.Normal)
self.AUEmailEdit.setPlaceholderText('*****@*****.**')
self.AUInstLabel = QLabel('institute')
self.AUInstComboBox = QComboBox()
siteList = getByColumnName("description",
describeInstitute(self.connection),
retrieveAllInstitute(self.connection))
self.AUInstComboBox.addItems(["{0}".format(x) for x in siteList])
self.AUFeedBackLabel = QLabel()
self.AUSubmitButton = QPushButton('Submit')
self.AUSubmitButton.clicked.connect(self.submitAURequest)
AddingUserTab.layout.addWidget(AddUserLabel, 0, 0, 1, 4)
AddingUserTab.layout.addWidget(self.AUNewUsernameLabel, 1, 0, 1, 1)
AddingUserTab.layout.addWidget(self.AUNewUsernameEdit, 1, 1, 1, 1)
AddingUserTab.layout.addWidget(self.AUPasswordLabel, 2, 0, 1, 1)
AddingUserTab.layout.addWidget(self.AUPasswordEdit, 2, 1, 1, 1)
AddingUserTab.layout.addWidget(self.AURePasswordLabel, 3, 0, 1, 1)
AddingUserTab.layout.addWidget(self.AURePasswordEdit, 3, 1, 1, 1)
AddingUserTab.layout.addWidget(self.AUNameLabel, 4, 0, 1, 1)
AddingUserTab.layout.addWidget(self.AUNameEdit, 4, 1, 1, 1)
AddingUserTab.layout.addWidget(self.AUFullNameLabel, 4, 2, 1, 1)
AddingUserTab.layout.addWidget(self.AUFullNameEdit, 4, 3, 1, 1)
AddingUserTab.layout.addWidget(self.AUEmailLabel, 5, 0, 1, 1)
AddingUserTab.layout.addWidget(self.AUEmailEdit, 5, 1, 1, 1)
AddingUserTab.layout.addWidget(self.AUInstLabel, 5, 2, 1, 1)
AddingUserTab.layout.addWidget(self.AUInstComboBox, 5, 3, 1, 1)
AddingUserTab.layout.addWidget(self.AUFeedBackLabel, 6, 0, 1, 3)
AddingUserTab.layout.addWidget(self.AUSubmitButton, 6, 3, 1, 1)
AddingUserTab.setLayout(AddingUserTab.layout)
self.MainTabs.setCurrentWidget(AddingUserTab)
#self.enableMenuItem(self.AddingUserTab, False)
def submitAURequest(self):
# check the password consistency
if self.AUNewUsernameEdit.text() == "" or self.AUNameEdit.text(
) == "" or self.AUFullNameEdit.text() == "":
self.AUFeedBackLabel.setText("key blank is empty")
return
if self.AUPasswordEdit.text() != self.AURePasswordEdit.text():
self.AUFeedBackLabel.setText("passwords are inconsistent")
self.AUPasswordEdit.setText("")
self.AURePasswordEdit.setText("")
return
try:
InstituteInfo = retrieveWithConstraint(
self.connection,
"institute",
description=str(self.AUInstComboBox.currentText()))
InstName = getByColumnName(
"institute", describeTable(self.connection, "institute"),
InstituteInfo)
TimeZone = getByColumnName(
"timezone", describeTable(self.connection, "institute"),
InstituteInfo)
except:
self.AUFeedBackLabel.setText(
"Failed to extract institute info, try to reconnect to DB")
Args = describeTable(self.connection, "people")
Data = []
Data.append(self.AUNewUsernameEdit.text())
Data.append(self.AUNameEdit.text())
Data.append(self.AUFullNameEdit.text())
Data.append(self.AUEmailEdit.text())
Data.append(InstName[0])
Data.append(self.AUPasswordEdit.text())
Data.append(TimeZone[0])
Data.append(0)
try:
createNewUser(self.connection, Args, Data)
self.AUFeedBackLabel.setText("Query submitted")
self.AUFeedBackLabel.setStyleSheet("color:green")
return
except:
print("submitFailed")
return
def updateProfile(self):
pass
##########################################################################
## Functions for Adding Users (END)
##########################################################################
##########################################################################
## Functions for Institutes display
##########################################################################
def displayInstitue(self):
self.processing.append("InstituteDisplay")
displayInstiTab = QWidget()
# Add tabs
self.MainTabs.addTab(displayInstiTab, "Institutes")
displayInstiTab.layout = QGridLayout(self)
dataList = ([describeInstitute(self.connection)] +
retrieveAllInstitute(self.connection))
proxy = QtDBTableWidget(dataList, 0)
lineEdit = QLineEdit()
lineEdit.textChanged.connect(proxy.on_lineEdit_textChanged)
view = QTableView()
view.setSortingEnabled(True)
comboBox = QComboBox()
comboBox.addItems(["{0}".format(x) for x in dataList[0]])
comboBox.currentIndexChanged.connect(
proxy.on_comboBox_currentIndexChanged)
label = QLabel()
label.setText("Regex Filter")
view.setModel(proxy)
view.setSelectionBehavior(QAbstractItemView.SelectRows)
view.setSelectionMode(QAbstractItemView.MultiSelection)
view.setEditTriggers(QAbstractItemView.NoEditTriggers)
displayInstiTab.layout.addWidget(lineEdit, 0, 1, 1, 1)
displayInstiTab.layout.addWidget(view, 1, 0, 1, 3)
displayInstiTab.layout.addWidget(comboBox, 0, 2, 1, 1)
displayInstiTab.layout.addWidget(label, 0, 0, 1, 1)
displayInstiTab.setLayout(displayInstiTab.layout)
self.MainTabs.setCurrentWidget(displayInstiTab)
##########################################################################
## Functions for Institutes display (END)
##########################################################################
##########################################################################
## Functions for Complaint submission
##########################################################################
def fileComplaint(self):
self.ComplaintTab = QWidget()
# Add tabs
self.MainTabs.addTab(self.ComplaintTab, "Complaint")
self.ComplaintAction.setDisabled(True)
self.ComplaintTab.layout = QGridLayout(self)
ComplaintLabel = QLabel(
'<font size="12"> Submit the complaint </font>')
ComplaintLabel.setMaximumHeight(60)
self.FCNameLabel = QLabel('Name:')
self.FCNameEdit = QLineEdit('')
self.FCNameEdit.setEchoMode(QLineEdit.Normal)
TableInfo = describeTable(self.connection, "people")
UserInfo = retrieveWithConstraint(self.connection,
"people",
username=self.TryUsername)
ShortName = getByColumnName("name", TableInfo, UserInfo)
if len(ShortName) > 0:
self.FCNameEdit.setText(str(ShortName[0]))
self.FCDateTimeLabel = QLabel('Date(local)')
self.FCDateTimeEdit = QDateTimeEdit()
self.FCDateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.FCCommentLabel = QLabel('Comment:')
self.FCCommentEdit = QTextEdit('')
self.FCCommentEdit.setPlaceholderText("Your comment")
self.FCFeedBackLabel = QLabel()
self.FCSubmitButton = QPushButton('Submit')
self.FCSubmitButton.clicked.connect(self.submitFCRequest)
self.ComplaintTab.layout.addWidget(ComplaintLabel, 0, 0, 1, 4,
Qt.AlignTop)
self.ComplaintTab.layout.addWidget(self.FCNameLabel, 1, 0, 1, 1)
self.ComplaintTab.layout.addWidget(self.FCNameEdit, 1, 1, 1, 1)
self.ComplaintTab.layout.addWidget(self.FCDateTimeLabel, 1, 2, 1, 1)
self.ComplaintTab.layout.addWidget(self.FCDateTimeEdit, 1, 3, 1, 1)
self.ComplaintTab.layout.addWidget(self.FCCommentLabel, 2, 0, 1, 4,
Qt.AlignLeft)
self.ComplaintTab.layout.addWidget(self.FCCommentEdit, 3, 0, 6, 4)
self.ComplaintTab.layout.addWidget(self.FCFeedBackLabel, 9, 0, 1, 2)
self.ComplaintTab.layout.addWidget(self.FCSubmitButton, 9, 3, 1, 1)
self.ComplaintTab.setLayout(self.ComplaintTab.layout)
self.MainTabs.setCurrentWidget(self.ComplaintTab)
def submitFCRequest(self):
if self.FCNameEdit.text() == "" or self.FCCommentEdit.toPlainText(
) == "":
self.FCFeedBackLabel.setText(
"Please make sure the name/comment are filled")
return
Args = describeTable(self.connection, "complaint")
Data = []
Data.append(self.FCDateTimeEdit.dateTime().toUTC().toString(
"yyyy-dd-MM hh:mm:ss.z"))
Data.append(self.FCCommentEdit.toPlainText())
Data.append(self.FCNameEdit.text())
print(Data)
try:
insertGenericTable(self.connection, "complaint", Args, Data)
except:
print("Failed to submit the text")
return
self.FCNameLabel.deleteLater()
self.FCNameEdit.deleteLater()
self.FCDateTimeLabel.deleteLater()
self.FCDateTimeEdit.deleteLater()
self.FCCommentLabel.deleteLater()
self.FCCommentEdit.deleteLater()
self.FCFeedBackLabel.deleteLater()
self.FCSubmitButton.deleteLater()
self.ComplaintTab.layout.removeWidget(self.FCNameLabel)
self.ComplaintTab.layout.removeWidget(self.FCNameEdit)
self.ComplaintTab.layout.removeWidget(self.FCDateTimeLabel)
self.ComplaintTab.layout.removeWidget(self.FCDateTimeEdit)
self.ComplaintTab.layout.removeWidget(self.FCCommentLabel)
self.ComplaintTab.layout.removeWidget(self.FCCommentEdit)
self.ComplaintTab.layout.removeWidget(self.FCFeedBackLabel)
self.ComplaintTab.layout.removeWidget(self.FCSubmitButton)
self.FCFeedBackLabel = QLabel("Submitted")
self.FCFeedBackLabel.setStyleSheet("color:green")
self.FCContinueButton = QPushButton('Continue')
self.FCContinueButton.clicked.connect(self.recreateFC)
self.ComplaintTab.layout.addWidget(self.FCFeedBackLabel, 1, 0, 1, 2)
self.ComplaintTab.layout.addWidget(self.FCContinueButton, 1, 3, 1, 1)
return
def recreateFC(self):
self.closeTab(self.MainTabs.currentIndex())
self.fileComplaint()
##########################################################################
## Functions for Complaint submission (END)
##########################################################################
def createHeadLine(self):
self.deactivateMenuBar()
self.HeadBox = QGroupBox()
self.HeadLayout = QHBoxLayout()
UsernameLabel = QLabel("Username:"******"Password:"******"Host IP:")
self.HostEdit = QLineEdit('128.146.38.1')
self.HostEdit.setEchoMode(QLineEdit.Normal)
self.HostEdit.setMinimumWidth(150)
self.HostEdit.setMaximumHeight(30)
DatabaseLabel = QLabel("Database:")
self.DatabaseEdit = QLineEdit('SampleDB')
self.DatabaseEdit.setEchoMode(QLineEdit.Normal)
self.DatabaseEdit.setMinimumWidth(150)
self.DatabaseEdit.setMaximumHeight(30)
self.ConnectButton = QPushButton("&Connect to DB")
self.ConnectButton.clicked.connect(self.connectDB)
self.HeadLayout.addWidget(UsernameLabel)
self.HeadLayout.addWidget(self.UsernameEdit)
self.HeadLayout.addWidget(PasswordLabel)
self.HeadLayout.addWidget(self.PasswordEdit)
self.HeadLayout.addWidget(HostLabel)
self.HeadLayout.addWidget(self.HostEdit)
self.HeadLayout.addWidget(DatabaseLabel)
self.HeadLayout.addWidget(self.DatabaseEdit)
self.HeadLayout.addWidget(self.ConnectButton)
self.HeadBox.setLayout(self.HeadLayout)
self.mainLayout.addWidget(self.HeadBox, 0, 0, self.GroupBoxSeg[0], 1)
def destroyHeadLine(self):
self.HeadBox.deleteLater()
self.mainLayout.removeWidget(self.HeadBox)
def clearLogInfo(self):
self.connection = "Offline"
def connectedHeadLine(self):
self.activateMenuBar()
self.HeadBox.deleteLater()
self.mainLayout.removeWidget(self.HeadBox)
self.HeadBox = QGroupBox()
self.HeadLayout = QHBoxLayout()
WelcomeLabel = QLabel("Hello,{}!".format(self.TryUsername))
statusString, colorString = checkDBConnection(self.connection)
DBStatusLabel = QLabel()
DBStatusLabel.setText("Database:{}/{}".format(self.TryHostAddress,
self.TryDatabase))
DBStatusValue = QLabel()
DBStatusValue.setText(statusString)
DBStatusValue.setStyleSheet(colorString)
self.SwitchButton = QPushButton("&Switch DB")
self.SwitchButton.clicked.connect(self.destroyHeadLine)
self.SwitchButton.clicked.connect(self.clearLogInfo)
self.SwitchButton.clicked.connect(self.createHeadLine)
self.HeadLayout.addWidget(WelcomeLabel)
self.HeadLayout.addStretch(1)
self.HeadLayout.addWidget(DBStatusLabel)
self.HeadLayout.addWidget(DBStatusValue)
self.HeadLayout.addWidget(self.SwitchButton)
self.HeadBox.setLayout(self.HeadLayout)
self.HeadBox.setLayout(self.HeadLayout)
self.mainLayout.addWidget(self.HeadBox, 0, 0, self.GroupBoxSeg[0], 1)
def createMain(self):
self.MainBodyBox = QGroupBox()
self.mainbodylayout = QHBoxLayout()
self.MainTabs = QTabWidget()
self.MainTabs.setTabsClosable(True)
self.MainTabs.tabCloseRequested.connect(
lambda index: self.closeTab(index))
self.mainbodylayout.addWidget(self.MainTabs)
self.MainBodyBox.setLayout(self.mainbodylayout)
self.mainLayout.addWidget(self.MainBodyBox, sum(self.GroupBoxSeg[0:1]),
0, self.GroupBoxSeg[1], 1)
def destroyMain(self):
self.MainBodyBox.deleteLater()
self.mainLayout.removeWidget(self.MainBodyBox)
def createApp(self):
self.AppOption = QGroupBox()
self.StartLayout = QHBoxLayout()
self.ResetButton = QPushButton("&Refresh")
self.FinishButton = QPushButton("&Finish")
self.FinishButton.setDefault(True)
self.FinishButton.clicked.connect(self.closeWindow)
self.StartLayout.addWidget(self.ResetButton)
self.StartLayout.addWidget(self.FinishButton)
self.StartLayout.addStretch(1)
self.AppOption.setLayout(self.StartLayout)
self.mainLayout.addWidget(self.AppOption, sum(self.GroupBoxSeg[0:2]),
0, self.GroupBoxSeg[2], 1)
def destroyApp(self):
self.AppOption.deleteLater()
self.mainLayout.removeWidget(self.AppOption)
def sendBackSignal(self):
self.backSignal = True
def connectDB(self):
try:
if isActive(self.connection):
self.TryUsername = self.master.TryUsername
self.TryHostAddress = self.master.TryHostAddress
self.TryDatabase = self.master.TryDatabase
self.connectedHeadLine()
return
self.TryUsername = self.UsernameEdit.text()
self.TryPassword = self.PasswordEdit.text()
self.TryHostAddress = self.HostEdit.text()
self.TryDatabase = self.DatabaseEdit.text()
if self.TryUsername == '':
msg.information(None, "Error", "Please enter a valid username",
QMessageBox.Ok)
return
self.connection = QtStartConnection(self.TryUsername,
self.TryPassword,
self.TryHostAddress,
self.TryDatabase)
if isActive(self.connection):
self.connectedHeadLine()
except Exception as err:
print("Error in connecting to database, {}".format(repr(err)))
def syncDB(self):
pass
def changeDBList(self):
self.DBNames = DBNames[str(self.HostName.currentText())]
self.DatabaseCombo.clear()
self.DatabaseCombo.addItems(self.DBNames)
self.DatabaseCombo.setCurrentIndex(0)
def closeTab(self, index):
self.releaseAction(self.MainTabs.tabText(index))
self.MainTabs.removeTab(index)
def releaseAction(self, text):
if text == "Adding User":
self.AddUserAction.setDisabled(False)
return
if text == "Complaint":
self.ComplaintAction.setDisabled(False)
return
if text == "Send Package":
self.sendPackAction.setDisabled(False)
return
if text == "Receive Package":
self.receivePackAction.setDisabled(False)
return
if text == "Insert Image":
self.InsertImgAction.setDisabled(False)
return
def closeWindow(self):
self.close()
self.release()
def occupied(self):
self.master.DBConsoleButton.setDisabled(True)
def release(self):
self.master.DBConsoleButton.setDisabled(False)
def closeEvent(self, event):
#Fixme: strict criterias for process checking should be added here:
#if self.ProcessingTest == True:
# QMessageBox.critical(self, 'Critical Message', 'There is running process, can not close!')
# event.ignore()
reply = QMessageBox.question(
self, 'Window Close',
'Are you sure you want to exit, all unsubmitted content will be lost?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
print('DB console terminated')
event.accept()
else:
event.ignore()
class Example(QWidget):
trigger = QtCore.pyqtSignal()
def __init__(self, parent=None):
super().__init__(parent, QtCore.Qt.Window)
self.top_warehouse = QFrame(self)
self.top_warehouse.setFrameShape(QFrame.StyledPanel)
self.top_warehouse.resize(584, 75)
self.top_warehouse.move(8, 10)
self.top_route = QFrame(self)
self.top_route.setFrameShape(QFrame.StyledPanel)
self.top_route.resize(584, 170)
self.top_route.move(8, 88)
self.top_supply = QFrame(self)
self.top_supply.setFrameShape(QFrame.StyledPanel)
self.top_supply.resize(285, 110)
self.top_supply.move(10, 92)
self.top_consumption = QFrame(self)
self.top_consumption.setFrameShape(QFrame.StyledPanel)
self.top_consumption.resize(286, 110)
self.top_consumption.move(304, 92)
self.combo_route = QComboBox(self)
self.combo_route.addItems(['1', '2', '3'])
self.combo_route.move(150, 220)
self.combo_route.resize(self.combo_route.sizeHint())
"""
Data entry for supply
"""
pars = parsing_tuple()
self.combo_supply = QComboBox(self)
self.combo_supply.addItems(pars)
self.combo_weight_party = QComboBox(self)
self.combo_weight_party.addItems(['20', '30', '40'])
self.date_supply = QDateTimeEdit()
vbox = QVBoxLayout()
layout = QHBoxLayout(self)
layout.addLayout(vbox)
layout.addWidget(self.combo_supply)
layout.addWidget(self.combo_weight_party)
layout.addWidget(self.date_supply)
layout.addStretch(1)
"""
Data entry for warehouse
"""
self.combo_warehouse = QComboBox(self)
self.combo_warehouse.addItems(pars)
self.combo_warehouse.move(150, 30)
self.combo_warehouse.resize(self.combo_warehouse.sizeHint())
self.lbl_warehouse = QLabel("Склады", self)
self.lbl_warehouse.move(300, 30)
"""
Data entry for consumption
"""
self.combo_consumption = QComboBox(self)
self.combo_consumption.addItems(pars)
self.date_consumption = QDateTimeEdit()
layout.addWidget(self.combo_consumption)
layout.addWidget(self.date_consumption)
self.check_route()
self.check_warehouse()
self.initUI()
def initUI(self):
btn_input = QPushButton('Ввести значения', self)
btn_input.resize(btn_input.sizeHint())
btn_input.move(420, 220)
btn_input.clicked.connect(self.get_supply_consumption)
btn_delete_route = QPushButton('Удалить маршруты', self)
btn_delete_route.resize(btn_delete_route.sizeHint())
btn_delete_route.move(310, 220)
btn_delete_route.clicked.connect(self.delete_route)
btn_delete_warehouse = QPushButton('Удалить склады', self)
btn_delete_warehouse.resize(btn_delete_warehouse.sizeHint())
btn_delete_warehouse.move(490, 55)
btn_delete_warehouse.clicked.connect(self.delete_warehouse)
btn_add_warehouse = QPushButton('Добавить склад', self)
btn_add_warehouse.resize(btn_delete_route.sizeHint())
btn_add_warehouse.move(40, 30)
btn_add_warehouse.clicked.connect(self.update_warehouse)
lbl_route = QLabel("Маршрут:", self)
lbl_route.resize(lbl_route.sizeHint())
lbl_route.move(100, 220)
lbl_supply = QLabel("Точка поставки", self)
lbl_supply.resize((lbl_supply.sizeHint()))
lbl_supply.move(90, 93)
lbl_consupmtion = QLabel("Точка потребления", self)
lbl_consupmtion.resize(lbl_consupmtion.sizeHint())
lbl_consupmtion.move(450, 93)
lbl_supply_point = QLabel("Пункт", self)
lbl_supply_point.resize(lbl_supply_point.sizeHint())
lbl_supply_point.move(25, 115)
lbl_weight_party = QLabel("Вес партии", self)
lbl_weight_party.resize(lbl_weight_party.sizeHint())
lbl_weight_party.move(70, 115)
lbl_date_departure = QLabel("Дата отправления", self)
lbl_date_departure.resize(lbl_date_departure.sizeHint())
lbl_date_departure.move(145, 115)
lbl_consumption_point = QLabel("Пункт", self)
lbl_consumption_point.resize(lbl_consumption_point.sizeHint())
lbl_consumption_point.move(420, 115)
lbl_date_arrival = QLabel("Дата прибытия", self)
lbl_date_arrival.resize(lbl_date_arrival.sizeHint())
lbl_date_arrival.move(490, 115)
self.setGeometry(300, 300, 600, 300)
self.setWindowTitle('Выбрать параметры поставки груза')
def check_route(self):
routs, session = session_getting_route()
before_route = 0
for route in routs:
if before_route != route.num_route:
self.combo_route.removeItem(route.num_route - 1)
before_route = route.num_route
session.close()
def delete_warehouse(self):
session_delete_warehouse()
self.check_warehouse()
pars = parsing_tuple()
self.combo_warehouse.clear()
self.combo_supply.clear()
self.combo_consumption.clear()
self.combo_warehouse.addItems(pars)
self.combo_supply.addItems(pars)
self.combo_consumption.addItems(pars)
def delete_route(self):
"""
delete data before use program
:return: nothing
"""
session_clear_field()
self.trigger.emit()
pars = parsing_tuple()
self.combo_warehouse.clear()
self.combo_supply.clear()
self.combo_consumption.clear()
self.combo_route.clear()
self.combo_warehouse.addItems(pars)
self.combo_supply.addItems(pars)
self.combo_consumption.addItems(pars)
main()
self.combo_route.addItems(['1', '2', '3'])
def check_warehouse(self):
str_warehouse = 'Склады:'
name_warehouse = session_get_warehouse()
for warehouse in name_warehouse:
str_warehouse = str_warehouse + warehouse.name_point + ','
self.lbl_warehouse.setText(str_warehouse)
self.lbl_warehouse.adjustSize()
def update_warehouse(self):
warehouse = self.combo_warehouse.currentText()
session_add_warehouse(warehouse)
self.check_warehouse()
pars = parsing_tuple()
self.combo_warehouse.clear()
self.combo_supply.clear()
self.combo_consumption.clear()
self.combo_warehouse.addItems(pars)
self.combo_supply.addItems(pars)
self.combo_consumption.addItems(pars)
def get_supply_consumption(self):
"""
Data collection from forms
:return: nothing
"""
supply = self.combo_supply.currentText()
consumption = self.combo_consumption.currentText()
route = self.combo_route.currentText()
date_arrival = datetime.datetime(
int(self.date_consumption.dateTime().toString("yyyy")),
int(self.date_consumption.dateTime().toString("MM")),
int(self.date_consumption.dateTime().toString("dd")),
int(self.date_consumption.dateTime().toString("hh")))
date_departure = datetime.datetime(
int(self.date_supply.dateTime().toString("yyyy")),
int(self.date_supply.dateTime().toString("MM")),
int(self.date_supply.dateTime().toString("dd")),
int(self.date_supply.dateTime().toString("hh")))
weight = int(self.combo_weight_party.currentText())
loading = loading_party(weight)
id_supply, num_party, empty_truck = session_create2(
weight=weight, supply=supply, date=date_departure, loading=loading)
unloading = unloading_party(weight)
travel_time = date_arrival - date_departure
id_consumption = session_add_consumption(consumption=consumption,
date=date_arrival,
unloading=unloading,
party=num_party,
travel_time=travel_time.days,
weight=weight)
agent = session_get_next_point()
parsing(agent)
if travel_time.days > 1:
optimal_route, warehouse_point = search_route_warehouse(
id_supply, id_consumption)
session_add_warehouse_party(optimal_route, warehouse_point,
num_party, loading, unloading)
else:
optimal_route = dijkstra(id_supply, id_consumption)
lst_pars = lst_optimal(optimal_route)
session_add_route(lst_pars, route, id_supply, empty_truck)
update_graphic()
self.trigger.emit()
self.check_route()
class EditActivity(AbstractActivityWidget):
save_needed = pyqtSignal(dict)
def __init__(self, activity, number, translator, guesser, *args):
self.guesser = guesser
self.name_label = QLabel()
self.name_edit = QComboBox()
self.name_edit.currentTextChanged.connect(self.check_for_change)
self.start_time_label = QLabel()
self.start_time_edit = QDateTimeEdit()
self.start_time_edit.dateTimeChanged.connect(self.check_for_change)
self.end_time_label = QLabel()
self.end_time_edit = QDateTimeEdit()
self.end_time_edit.dateTimeChanged.connect(self.check_for_change)
self.calories_label = QLabel()
self.calories_edit = QDoubleSpinBox()
self.calories_edit.valueChanged.connect(self.check_for_change)
self.save_button = QPushButton()
self.save_button.setText(translator.save_button)
self.save_button.setDisabled(True)
self.save_button.clicked.connect(self.save_button_clicked)
self.margins = 0, 0, 0, 0
self.label_edit_spacing = 4
super(EditActivity, self).__init__(activity, number, translator, *args)
def layout_widget(self, layout):
self.name_label.setText(self.translator.activity_name_label)
for name in activity_number_map.keys():
self.name_edit.addItem(name)
if activity_number_map[name] == self.activity['activity_no']:
self.name_edit.setCurrentText(name)
name_wrapper = QWidget()
name_wrapper.setContentsMargins(*self.margins)
name_layout = QHBoxLayout()
name_layout.setSpacing(self.label_edit_spacing)
name_layout.addWidget(self.name_label)
name_layout.addWidget(self.name_edit)
name_layout.addStretch()
name_wrapper.setLayout(name_layout)
layout.addWidget(name_wrapper)
time_wrapper = QWidget()
time_wrapper.setContentsMargins(*self.margins)
time_layout = QHBoxLayout()
time_layout.setSpacing(self.label_edit_spacing)
self.start_time_label.setText(self.translator.activity_start_time_label)
self.start_time_edit.setDateTime(self.activity['start_time'])
time_layout.addWidget(self.start_time_label)
time_layout.addWidget(self.start_time_edit)
time_layout.addStretch(1)
self.end_time_label.setText(self.translator.activity_end_time_label)
self.end_time_edit.setDateTime(self.activity['end_time'])
time_layout.addWidget(self.end_time_label)
time_layout.addWidget(self.end_time_edit)
time_wrapper.setLayout(time_layout)
layout.addWidget(time_wrapper)
calories_save_wrapper = QWidget()
calories_save_wrapper.setContentsMargins(*self.margins)
calories_save_layout = QHBoxLayout()
calories_save_layout.setSpacing(self.label_edit_spacing)
self.calories_label.setText(self.translator.calories_label)
self.calories_edit.setRange(0, 4500)
self.calories_edit.setSingleStep(1)
self.calories_edit.setDecimals(3)
self.calories_edit.setValue(self.activity['calories'] if 'calories' in self.activity else
self.guesser.guess_kcal(self.activity))
calories_save_layout.addWidget(self.calories_label)
calories_save_layout.addWidget(self.calories_edit)
calories_save_layout.addStretch()
calories_save_layout.addWidget(self.save_button)
calories_save_wrapper.setLayout(calories_save_layout)
layout.addWidget(calories_save_wrapper)
self.check_for_change()
def check_for_change(self):
if (self.activity['activity'] != self.name_edit.currentText() or
self.activity['start_time'] != self.start_time_edit.dateTime().toPyDateTime() or
self.activity['end_time'] != self.end_time_edit.dateTime().toPyDateTime() or
('calories' in self.activity and abs(self.activity['calories'] - self.calories_edit.value()) > 0.01) or
('calories' not in self.activity and abs(
self.guesser.guess_kcal(self.activity) - self.calories_edit.value()) > 0.01)):
self.save_button.setDisabled(False)
else:
self.save_button.setDisabled(True)
def set_activity(self, activity):
super(EditActivity, self).set_activity(activity)
def save_button_clicked(self):
changed_activity = self.activity.copy()
changed_activity['activity'] = self.name_edit.currentText()
changed_activity['activity_no'] = activity_number_map[self.name_edit.currentText()]
changed_activity['start_time'] = self.start_time_edit.dateTime().toPyDateTime()
changed_activity['end_time'] = self.end_time_edit.dateTime().toPyDateTime()
if (('calories' in self.activity and abs(self.activity['calories'] - self.calories_edit.value()) > 0.01) or
abs(self.guesser.guess_kcal(self.activity) - self.calories_edit.value()) > 0.01):
changed_activity['calories'] = self.calories_edit.value()
self.activity = changed_activity
self.save_needed.emit(changed_activity)
class Setting(QWidget, Ui_widget_setting):
signal_core_number = pyqtSignal(int)
signal_suspend_status = pyqtSignal(bool)
signal_waiting_min = pyqtSignal(int)
signal_schedule_status = pyqtSignal(bool)
signal_cancel_plan = pyqtSignal(str)
signal_change_language = pyqtSignal(str)
def __init__(self, suspend, cores, schedule_status, waiting_min, language):
super().__init__()
self.setupUi(self)
# ----------init variable------------
self.suspend = suspend
self.cores = cores
self.schedule_status = schedule_status
self.waiting_min = waiting_min
self.language = language
self.language_list = ['English', 'Chinese']
# ----------init widget--------------
self.label_suspend = QTreeWidgetItem()
self.checkbox_suspend = QCheckBox()
self.label_cores = QTreeWidgetItem()
self.edit_cores = QSpinBox()
self.label_plan = QTreeWidgetItem()
self.edit_plan_datetime = QDateTimeEdit()
self.label_about = QTreeWidgetItem()
self.label_language = QTreeWidgetItem()
self.combobox_lauguage = QComboBox()
# -----------init function----------------
self.ui_set()
self.btn()
self.init_data_show()
self.self_translate(language)
self.show()
def btn(self):
self.tree_setting.itemClicked.connect(self.effect_expand)
self.tree_setting.itemChanged.connect(self.enable_schedule)
self.combobox_lauguage.activated.connect(self.choose_language)
self.checkbox_suspend.stateChanged.connect(self.change_suspend_status)
def ui_set(self):
# style
self.setStyleSheet(
"QSpinBox{border:1.5px solid #778899;border-radius:4px; padding:2px 2px}"
"QDateTimeEdit{border:1.5px solid #778899;border-radius:4px; padding:2px 2px}"
)
self.tree_setting.setColumnWidth(0, 180)
self.tree_setting.expandItem(self.tree_setting.topLevelItem(0))
self.tree_setting.topLevelItem(1).setCheckState(1, 0)
self.edit_cores.setMaximumSize(50, 25)
self.edit_cores.setContentsMargins(0, 4, 0, 0)
self.edit_cores.setMinimum(1)
self.edit_cores.setMaximum(132)
self.label_plan.setDisabled(True)
self.edit_plan_datetime.setMaximumSize(135, 28)
self.edit_plan_datetime.setDisabled(True)
self.combobox_lauguage.setMaximumSize(135, 28)
self.combobox_lauguage.addItems(self.language_list)
self.combobox_lauguage.setCurrentText(self.language)
# function
self.add_tree_item(0, self.label_suspend, "暂停队列",
self.checkbox_suspend)
self.add_tree_item(0, self.label_cores, "使用核数", self.edit_cores)
self.add_tree_item(1, self.label_plan, "计划启动于",
self.edit_plan_datetime)
self.add_tree_item(2, self.label_language, "语言选择",
self.combobox_lauguage)
def add_tree_item(self, top_level_index, label, label_name, input_edit):
label.setText(0, label_name)
self.tree_setting.topLevelItem(top_level_index).addChild(label)
self.tree_setting.setItemWidget(label, 1, input_edit)
def effect_expand(self, item, column):
index = self.tree_setting.indexOfTopLevelItem(item)
if index >= 0:
if item.isExpanded():
item.setExpanded(False)
else:
item.setExpanded(True)
def enable_schedule(self, item, column):
index = self.tree_setting.indexOfTopLevelItem(item)
if index == 1:
check_state = item.checkState(column)
self.schedule_status = bool(check_state)
self.label_plan.setDisabled(2 - check_state)
self.edit_plan_datetime.setEnabled(check_state)
item.setExpanded(2 - check_state)
self.reset_date_edit()
self.suspend = self.checkbox_suspend.checkState()
self.checkbox_suspend.setCheckState(self.suspend + check_state)
self.checkbox_suspend.setDisabled(check_state)
def init_data_show(self):
self.edit_cores.setValue(self.cores)
self.checkbox_suspend.setCheckState(self.suspend * 2)
if self.schedule_status:
self.tree_setting.topLevelItem(1).setCheckState(1, 2)
self.label_plan.setDisabled(False)
self.edit_plan_datetime.setEnabled(True)
self.tree_setting.topLevelItem(1).setExpanded(True)
waiting_seconds = self.waiting_min * 60
self.edit_plan_datetime.setDisplayFormat("yyyy/MM/dd HH:mm")
self.edit_plan_datetime.setDateTime(
QDateTime.currentDateTime().addSecs(waiting_seconds))
else:
self.reset_date_edit()
def reset_date_edit(self):
self.edit_plan_datetime.setDisplayFormat("yyyy/MM/dd HH:mm")
self.edit_plan_datetime.setDateTime(QDateTime.currentDateTime())
self.edit_plan_datetime.setMinimumDateTime(QDateTime.currentDateTime())
self.edit_plan_datetime.setMaximumDateTime(
QDateTime.currentDateTime().addDays(5))
self.edit_plan_datetime.setCalendarPopup(True)
def change_suspend_status(self, status):
self.suspend = bool(status)
def plan_start(self):
curr_time = QDateTime.currentSecsSinceEpoch()
schedule_time = self.edit_plan_datetime.dateTime().toSecsSinceEpoch()
self.waiting_min = int(round((schedule_time - curr_time) / 60, 0))
print('waiting min', self.waiting_min)
self.signal_waiting_min.emit(self.waiting_min)
def choose_language(self):
language = self.combobox_lauguage.currentText()
self.signal_change_language.emit(language)
self.self_translate(language)
def self_translate(self, language):
if language == 'English':
self.label_suspend.setText(0, 'Suspend next')
self.label_cores.setText(0, 'Threads number')
self.label_plan.setText(0, 'Scheduled in')
self.label_language.setText(0, 'Language')
else:
self.label_suspend.setText(0, "暂停队列")
self.label_cores.setText(0, "使用核数")
self.label_plan.setText(0, "计划启动于")
self.label_language.setText(0, "语言选择")
self.retranslateUi(self)
def closeEvent(self, event):
self.cores = self.edit_cores.value()
suspend_status = self.checkbox_suspend.checkState()
self.signal_core_number.emit(self.cores)
self.signal_schedule_status.emit(self.schedule_status)
if self.schedule_status:
self.plan_start()
else:
self.signal_cancel_plan.emit(' ')
self.signal_suspend_status.emit(bool(suspend_status))
self.close()
class QtImageInsertionTab(QWidget):
def __init__(self, master):
super(QtImageInsertionTab, self).__init__()
self.master = master
self.connection = self.master.connection
self.Inserted = False
self.mainlayout = QGridLayout()
self.insertBox()
self.setLayout(self.mainlayout)
def insertBox(self):
self.InsertBox = QGroupBox()
self.InsertLayout = QGridLayout()
self.InsertImage = QLabel('<font size="12">Insert Image:</font>')
self.InsertImage.setMaximumHeight(60)
self.ModuleIDLabel = QLabel("Module ID:")
self.ModuleIDEdit = QLineEdit()
self.ModuleIDEdit.setEchoMode(QLineEdit.Normal)
self.DateTimeLabel = QLabel('Time:')
self.DateTimeEdit = QDateTimeEdit()
self.DateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.CaptionLabel = QLabel("Caption:")
self.CaptionEdit = QLineEdit()
self.CaptionEdit.setEchoMode(QLineEdit.Normal)
self.CaptionEdit.setPlaceholderText("description")
self.ImageLabel = QLabel("Image:")
self.ImageEdit = QLineEdit()
self.ImageEdit.setEchoMode(QLineEdit.Normal)
self.ImageEdit.setPlaceholderText("image")
self.ImageEdit.setDisabled(True)
self.ImageButton = QPushButton("&Browser..")
self.ImageButton.clicked.connect(self.openImageBrowser)
self.FeedBackLabel = QLabel("")
self.InsertButton = QPushButton("&Submit")
self.InsertButton.clicked.connect(self.submitRequest)
self.InsertLayout.addWidget(self.InsertImage, 0, 0, 1, 4, Qt.AlignTop)
self.InsertLayout.addWidget(self.ModuleIDLabel, 1, 0, 1, 1)
self.InsertLayout.addWidget(self.ModuleIDEdit, 1, 1, 1, 1)
self.InsertLayout.addWidget(self.DateTimeLabel, 1, 2, 1, 1)
self.InsertLayout.addWidget(self.DateTimeEdit, 1, 3, 1, 1)
self.InsertLayout.addWidget(self.CaptionLabel, 2, 0, 1, 1)
self.InsertLayout.addWidget(self.CaptionEdit, 2, 1, 1, 1)
self.InsertLayout.addWidget(self.ImageLabel, 3, 0, 1, 1)
self.InsertLayout.addWidget(self.ImageEdit, 3, 1, 1, 1)
self.InsertLayout.addWidget(self.ImageButton, 3, 3, 1, 1)
self.InsertLayout.addWidget(self.FeedBackLabel, 4, 0, 1, 10)
self.InsertLayout.addWidget(self.InsertButton, 4, 10, 1, 1)
self.InsertBox.setLayout(self.InsertLayout)
self.mainlayout.addWidget(self.InsertBox, 0, 0, 1, 1)
def submitRequest(self):
self.InsertButton.setDisabled(True)
if self.ModuleIDEdit.text() == "":
self.FeedBackLabel.setStyleSheet("color:red")
self.FeedBackLabel.setText("Failed: Module_ID is missing")
if self.SelectedFile != "":
file_stat = os.stat(self.SelectedFile)
if file_stat.st_size / (1024.0 * 1024.0) > 10.0:
self.FeedBackLabel.setStyleSheet("color:red")
self.FeedBackLabel.setText(
"Failed: the image size exceeds 10 Mb")
return
try:
args = describeTable(self.connection, "images")
Data = []
SubmitArgs = []
for arg in args:
if "_id" in arg:
Data.append(self.ModuleIDEdit.text())
SubmitArgs.append(arg)
if "date" in arg:
Data.append(self.DateTimeEdit.dateTime().toUTC().toString(
"yyyy-dd-MM hh:mm:ss.z"))
SubmitArgs.append(arg)
if "username" in arg:
Data.append(self.master.TryUsername)
SubmitArgs.append(arg)
if "caption" in arg:
Data.append(self.CaptionEdit.text())
SubmitArgs.append(arg)
if "image" in arg:
binaryData = self.GetBinary(self.SelectedFile)
Data.append(binaryData)
SubmitArgs.append(arg)
self.Inserted = insertGenericTable(self.connection, "images",
SubmitArgs, Data)
except Exception as err:
print(err)
self.FeedBackLabel.setStyleSheet("color:red")
self.FeedBackLabel.setText("Failed: Submission is unsuccessful")
self.InsertButton().setDisabled(False)
return
if self.Inserted == False:
self.FeedBackLabel.setStyleSheet("color:red")
self.FeedBackLabel.setText("Failed: Submission is unsuccessful")
self.InsertButton().setDisabled(False)
return
self.ModuleIDLabel.deleteLater()
self.ModuleIDEdit.deleteLater()
self.DateTimeLabel.deleteLater()
self.DateTimeEdit.deleteLater()
self.CaptionLabel.deleteLater()
self.CaptionEdit.deleteLater()
self.ImageLabel.deleteLater()
self.ImageEdit.deleteLater()
self.ImageButton.deleteLater()
self.FeedBackLabel.deleteLater()
self.InsertButton.deleteLater()
self.InsertLayout.removeWidget(self.ModuleIDLabel)
self.InsertLayout.removeWidget(self.ModuleIDEdit)
self.InsertLayout.removeWidget(self.DateTimeLabel)
self.InsertLayout.removeWidget(self.DateTimeEdit)
self.InsertLayout.removeWidget(self.CaptionLabel)
self.InsertLayout.removeWidget(self.CaptionEdit)
self.InsertLayout.removeWidget(self.ImageLabel)
self.InsertLayout.removeWidget(self.ImageEdit)
self.InsertLayout.removeWidget(self.ImageButton)
self.InsertLayout.removeWidget(self.FeedBackLabel)
self.InsertLayout.removeWidget(self.InsertButton)
self.FeedBackLabel = QLabel("Submitted")
self.FeedBackLabel.setStyleSheet("color:green")
self.ContinueButton = QPushButton('Continue')
self.ContinueButton.clicked.connect(self.recreateTab)
self.CloseButton = QPushButton('Close')
self.CloseButton.clicked.connect(self.closeTab)
self.InsertLayout.addWidget(self.FeedBackLabel, 1, 0, 1, 2)
self.InsertLayout.addWidget(self.ContinueButton, 1, 9, 1, 1)
self.InsertLayout.addWidget(self.CloseButton, 1, 10, 1, 1)
def openImageBrowser(self):
try:
ImageBrowser = QFileDialog()
options = ImageBrowser.Option()
options |= ImageBrowser.DontUseNativeDialog
ImageBrowser.setFileMode(QFileDialog.ExistingFiles)
ImageBrowser.setNameFilter(
("All Files (*);;Images (*.jpeg *.jpg *.png *.gif)"))
if ImageBrowser.exec_():
self.SelectedFileList = ImageBrowser.selectedFiles()
if len(self.SelectedFileList) == 0:
return
self.SelectedFile = self.SelectedFileList[0]
if self.SelectedFile.split('.')[-1] not in [
"jpeg", "jpg", "png", "gif"
]:
QMessageBox.information(None, "Warning",
"Not a valid image file",
QMessageBox.Ok)
self.ImageEdit.setText(self.SelectedFile)
except Exception as err:
print(err)
QMessageBox.information(None, "Warning", "File did not selected",
QMessageBox.Ok)
def GetBinary(self, filename):
with open(filename, 'rb') as file:
binaryData = file.read()
return binaryData
def recreateTab(self):
self.master.closeTab(self.master.MainTabs.currentIndex())
self.master.insertImage()
def closeTab(self):
self.master.closeTab(self.master.MainTabs.currentIndex())
class Downtime(QDialog):
"""
Class who create Downtime QDialog for hosts/services
"""
def __init__(self, parent=None):
super(Downtime, self).__init__(parent)
self.setWindowTitle('Request a Downtime')
self.setWindowFlags(Qt.FramelessWindowHint)
self.setStyleSheet(get_css())
self.setWindowIcon(QIcon(get_image_path('icon')))
self.setMinimumSize(360, 460)
# Fields
self.fixed = True
self.duration = QTimeEdit()
self.start_time = QDateTimeEdit()
self.end_time = QDateTimeEdit()
self.comment_edit = QTextEdit()
def initialize(self, item_type, item_name, comment):
"""
Initialize Downtime QDialog
:param item_type: type of item to acknowledge : host | service
:type item_type: str
:param item_name: name of the item to acknowledge
:type item_name: str
:param comment: the default comment of action
:type comment: str
"""
# Main layout
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.addWidget(get_logo_widget(self))
downtime_widget = QWidget()
downtime_widget.setObjectName('login')
downtime_layout = QGridLayout(downtime_widget)
ack_title = QLabel('<h2>Request a downtime</h2>')
downtime_layout.addWidget(ack_title, 0, 0, 1, 3)
host_label = QLabel('<h2>%s: %s</h2>' %
(item_type.capitalize(), item_name))
downtime_layout.addWidget(host_label, 1, 0, 1, 1)
options_label = QLabel('Downtime options:')
options_label.setObjectName('actions')
downtime_layout.addWidget(options_label, 2, 0, 1, 1)
fixed_checkbox = QCheckBox()
fixed_checkbox.setObjectName('actions')
fixed_checkbox.setChecked(self.fixed)
fixed_checkbox.setFixedSize(18, 18)
downtime_layout.addWidget(fixed_checkbox, 2, 1, 1, 1)
fixed_label = QLabel('Fixed')
fixed_label.setObjectName('actions')
downtime_layout.addWidget(fixed_label, 2, 2, 1, 1)
fixed_info = QLabel(
'<i>If checked, downtime will start and end at the times specified'
' by the “start time” and “end time” fields.</i>')
fixed_info.setWordWrap(True)
downtime_layout.addWidget(fixed_info, 3, 0, 1, 3)
duration_label = QLabel('Duration')
duration_label.setObjectName('actions')
downtime_layout.addWidget(duration_label, 4, 0, 1, 1)
duration_clock = QLabel()
duration_clock.setPixmap(QPixmap(get_image_path('clock')))
downtime_layout.addWidget(duration_clock, 4, 1, 1, 1)
duration_clock.setFixedSize(16, 16)
duration_clock.setScaledContents(True)
self.duration.setTime(QTime(4, 00))
self.duration.setDisplayFormat("HH'h'mm")
downtime_layout.addWidget(self.duration, 4, 2, 1, 1)
duration_info = QLabel(
'<i>Sets the duration if it is a non-fixed downtime.</i>')
downtime_layout.addWidget(duration_info, 5, 0, 1, 3)
date_range_label = QLabel('Downtime date range')
date_range_label.setObjectName('actions')
downtime_layout.addWidget(date_range_label, 6, 0, 1, 1)
calendar_label = QLabel()
calendar_label.setPixmap(QPixmap(get_image_path('calendar')))
calendar_label.setFixedSize(16, 16)
calendar_label.setScaledContents(True)
downtime_layout.addWidget(calendar_label, 6, 1, 1, 1)
start_time_label = QLabel('Start time:')
downtime_layout.addWidget(start_time_label, 7, 0, 1, 1)
self.start_time.setCalendarPopup(True)
self.start_time.setDateTime(datetime.datetime.now())
self.start_time.setDisplayFormat("dd/MM/yyyy HH'h'mm")
downtime_layout.addWidget(self.start_time, 7, 1, 1, 2)
end_time_label = QLabel('End time:')
downtime_layout.addWidget(end_time_label, 8, 0, 1, 1)
self.end_time.setCalendarPopup(True)
self.end_time.setDateTime(datetime.datetime.now() +
datetime.timedelta(hours=2))
self.end_time.setDisplayFormat("dd/MM/yyyy HH'h'mm")
downtime_layout.addWidget(self.end_time, 8, 1, 1, 2)
self.comment_edit.setText(comment)
self.comment_edit.setMaximumHeight(60)
downtime_layout.addWidget(self.comment_edit, 9, 0, 1, 3)
request_btn = QPushButton('REQUEST DOWNTIME', self)
request_btn.clicked.connect(self.handle_accept)
request_btn.setObjectName('valid')
request_btn.setMinimumHeight(30)
request_btn.setDefault(True)
downtime_layout.addWidget(request_btn, 10, 0, 1, 3)
main_layout.addWidget(downtime_widget)
def duration_to_seconds(self):
"""
Return "duration" QTimeEdit value in seconds
:return: "duration" in seconds
:rtype: int
"""
return QTime(0, 0).secsTo(self.duration.time())
def handle_accept(self):
"""
Check if end_time timestamp is not lower than start_time
"""
if self.start_time.dateTime().toTime_t() > self.end_time.dateTime(
).toTime_t():
logger.warning(
'Try to add Downtime with "End Time" lower than "Start Time"')
else:
self.accept()
def mousePressEvent(self, event):
""" QWidget.mousePressEvent(QMouseEvent) """
self.offset = event.pos()
def mouseMoveEvent(self, event):
""" QWidget.mousePressEvent(QMouseEvent) """
try:
x = event.globalX()
y = event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x - x_w, y - y_w)
except AttributeError as e:
logger.warning('Move Event %s: %s', self.objectName(), str(e))
class AnalyzerUi(QWidget):
task_finish_signal = pyqtSignal()
TABLE_HEADER_SELECTOR = ['', 'Selector', 'Comments', 'UUID', 'Status']
TABLE_HEADER_ANALYZER = ['', 'Strategy', 'Comments', 'UUID', 'Status']
def __init__(self, data_hub_entry: DataHubEntry,
strategy_entry: StrategyEntry):
super(AnalyzerUi, self).__init__()
self.__data_hub_entry = data_hub_entry
self.__strategy_entry = strategy_entry
self.__analyzer_info = self.__strategy_entry.analyzer_info()
# Thread and task related
self.__selector_list = []
self.__analyzer_list = []
self.__result_output = StockAnalysisSystem().get_project_path()
self.__timing_clock = Clock()
self.__progress_rate = ProgressRate()
self.task_finish_signal.connect(self.__on_task_done)
# Timer for update status
self.__timer = QTimer()
self.__timer.setInterval(1000)
self.__timer.timeout.connect(self.on_timer)
self.__timer.start()
# UI related
group, layout = create_v_group_box('Selector')
self.__group_selector = group
self.__layout_selector = layout
group, layout = create_v_group_box('Analyzer')
self.__group_analyzer = group
self.__layout_analyzer = layout
group, layout = create_v_group_box('Option')
self.__group_option = group
self.__layout_option = layout
group, layout = create_h_group_box('Result')
self.__group_result = group
self.__layout_result = layout
self.__table_selector = TableViewEx()
self.__table_analyzer = TableViewEx()
# self.__radio_group_selector = QButtonGroup(self)
# self.__radio_all = QRadioButton('All')
# self.__radio_tags = QRadioButton('Tags')
# self.__radio_manual = QRadioButton('Manual')
# self.__table_preview = QTableWidget()
self.__check_force_calc = QCheckBox('Force Calc')
self.__check_auto_cache = QCheckBox('Cache Result')
self.__check_load_json = QCheckBox('Load Json')
self.__check_dump_json = QCheckBox('Dump Json')
self.__check_load_dump_all = QCheckBox('Load/Dump All')
self.__datetime_time_since = QDateTimeEdit(years_ago(5))
self.__datetime_time_until = QDateTimeEdit(now())
self.__edit_path = QLineEdit('analysis_report.xlsx')
self.__button_browse = QPushButton('Browse')
self.__button_selector = QPushButton('Selector')
self.__button_analyzer = QPushButton('Analyzer')
self.__button_result = QPushButton('Result')
self.__button_run_strategy = QPushButton('Run Strategy')
self.__check_attach_basic_index = QCheckBox('Attach Basic Index')
self.init_ui()
self.update_selector()
self.update_analyzer()
# ---------------------------------------------------- UI Init -----------------------------------------------------
def init_ui(self):
self.__layout_control()
self.__config_control()
def __layout_control(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
self.setMinimumSize(600, 400)
self.__layout_selector.addWidget(self.__table_selector)
main_layout.addWidget(self.__group_selector)
self.__layout_analyzer.addWidget(self.__table_analyzer)
main_layout.addWidget(self.__group_analyzer)
self.__layout_result.addWidget(self.__edit_path)
self.__layout_result.addWidget(self.__button_browse)
main_layout.addWidget(self.__group_result)
grid_layout = QGridLayout()
grid_layout.addWidget(self.__check_force_calc, 0, 0)
grid_layout.addWidget(self.__check_auto_cache, 1, 0)
grid_layout.addWidget(self.__check_load_json, 0, 1)
grid_layout.addWidget(self.__check_dump_json, 1, 1)
grid_layout.addWidget(QLabel(' '), 0, 2)
grid_layout.addWidget(QLabel(' '), 0, 2)
grid_layout.addWidget(QLabel('Since'), 0, 3)
grid_layout.addWidget(QLabel('Until'), 1, 3)
grid_layout.addWidget(self.__datetime_time_since, 0, 4)
grid_layout.addWidget(self.__datetime_time_until, 1, 4)
grid_layout.addWidget(self.__check_attach_basic_index, 2, 0, 3, 1)
grid_layout.addWidget(self.__check_load_dump_all, 2, 1, 3, 1)
self.__layout_option.addLayout(grid_layout)
main_layout.addWidget(self.__group_option)
bottom_control_area = QHBoxLayout()
main_layout.addLayout(bottom_control_area)
bottom_control_area.addWidget(QLabel('Strategy Flow: '), 99)
bottom_control_area.addWidget(self.__button_selector)
bottom_control_area.addWidget(QLabel('==>'))
bottom_control_area.addWidget(self.__button_analyzer)
bottom_control_area.addWidget(QLabel('==>'))
bottom_control_area.addWidget(self.__button_result)
bottom_control_area.addWidget(QLabel(' | '))
bottom_control_area.addWidget(self.__button_run_strategy)
def __config_control(self):
self.__table_selector.SetCheckableColumn(0)
self.__table_selector.SetColumn(AnalyzerUi.TABLE_HEADER_SELECTOR)
self.__table_selector.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.__table_analyzer.SetCheckableColumn(0)
self.__table_analyzer.SetColumn(AnalyzerUi.TABLE_HEADER_ANALYZER)
self.__table_analyzer.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.__check_auto_cache.setChecked(True)
self.__datetime_time_since.setCalendarPopup(True)
self.__datetime_time_until.setCalendarPopup(True)
self.__check_force_calc.setToolTip('勾选此项后，程序将不会从缓存中读取分析结果，并强制进行实时计算。')
self.__check_auto_cache.setToolTip('勾选此项后，程序会自动缓存分析结果到SasCache数据库')
self.__check_load_json.setToolTip('仅供Debug：从JSON文件中载入分析结果')
self.__check_dump_json.setToolTip('仅供Debug：将分析结果写入JSON文件中')
self.__check_load_dump_all.setToolTip(
'仅供Debug：载入/保存所有结果而不是按Analyzer分别载入/保存')
self.__layout_selector.setSpacing(0)
self.__layout_analyzer.setSpacing(0)
self.__layout_option.setSpacing(0)
self.__layout_result.setSpacing(0)
self.__layout_selector.setContentsMargins(0, 0, 0, 0)
self.__layout_analyzer.setContentsMargins(0, 0, 0, 0)
# self.__layout_result.setContentsMargins(0, 0, 0, 0)
self.__button_result.clicked.connect(self.on_button_browse)
self.__button_browse.clicked.connect(self.on_button_browse)
self.__button_selector.clicked.connect(self.on_button_selector)
self.__button_analyzer.clicked.connect(self.on_button_analyzer)
self.__button_run_strategy.clicked.connect(self.on_button_run_strategy)
def on_button_browse(self):
file_path, ok = QFileDialog.getSaveFileName(
self, 'Select Result Excel Path', '',
'XLSX Files (*.xlsx);;All Files (*)')
if ok:
self.__edit_path.setText(file_path)
def on_button_selector(self):
self.__group_selector.setVisible(True)
self.__group_analyzer.setVisible(not self.__group_analyzer.isVisible())
def on_button_analyzer(self):
self.__group_analyzer.setVisible(True)
self.__group_selector.setVisible(not self.__group_selector.isVisible())
def on_button_run_strategy(self):
selector_list = []
analyzer_list = []
output_path = self.__edit_path.text()
if len(output_path.strip()) == 0:
QMessageBox.information(
self, QtCore.QCoreApplication.translate('', '配置缺失'),
QtCore.QCoreApplication.translate('', '请指定结果输出文件'),
QMessageBox.Close, QMessageBox.Close)
for i in range(self.__table_analyzer.RowCount()):
if self.__table_analyzer.GetItemCheckState(i,
0) == QtCore.Qt.Checked:
uuid = self.__table_analyzer.GetItemText(i, 3)
analyzer_list.append(uuid)
if len(analyzer_list) == 0:
QMessageBox.information(None, '提示', '请至少选择一个分析方法')
return
self.__selector_list = selector_list
self.__analyzer_list = analyzer_list
self.__result_output = output_path
self.execute_update_task()
def on_timer(self):
for i in range(self.__table_analyzer.RowCount()):
uuid = self.__table_analyzer.GetItemText(i, 3)
if self.__progress_rate.has_progress(uuid):
rate = self.__progress_rate.get_progress_rate(uuid)
self.__table_analyzer.SetItemText(i, 4,
'%.2f%%' % (rate * 100))
else:
self.__table_analyzer.SetItemText(i, 4, '')
def closeEvent(self, event):
if self.__task_thread is not None:
QMessageBox.information(
self, QtCore.QCoreApplication.translate('', '无法关闭窗口'),
QtCore.QCoreApplication.translate('', '策略运行过程中无法关闭此窗口'),
QMessageBox.Close, QMessageBox.Close)
event.ignore()
else:
event.accept()
# --------------------------------------------------------------------------------------
def update_selector(self):
self.__table_selector.Clear()
self.__table_selector.SetRowCount(0)
self.__table_selector.SetColumn(AnalyzerUi.TABLE_HEADER_SELECTOR)
self.__table_selector.AppendRow(
['', '所有股票', '当前只支持所有股票，不选默认也是所有股票', '-'])
# Add check box
# check_item = QTableWidgetItem()
# check_item.setCheckState(QtCore.Qt.Unchecked)
# self.__table_selector.setItem(0, 0, check_item)
def update_analyzer(self):
self.__table_analyzer.Clear()
self.__table_analyzer.SetRowCount(0)
self.__table_analyzer.SetColumn(AnalyzerUi.TABLE_HEADER_ANALYZER)
for method_uuid, method_name, method_detail, _ in self.__analyzer_info:
line = [
'', # Place holder for check box
method_name,
method_detail,
method_uuid,
'', # Place holder for status
]
self.__table_analyzer.AppendRow(line)
# index = self.__table_analyzer.RowCount() - 1
# Add check box
# check_item = QTableWidgetItem()
# check_item.setCheckState(QtCore.Qt.Unchecked)
# self.__table_analyzer.setItem(index, 0, check_item)
# --------------------------------------------------------------------------
# def load_analyzer_info(self) -> [(str, str, str)]:
# info = []
# probs = self.__strategy_entry.strategy_prob()
# for prob in probs:
# methods = prob.get('methods', [])
# for method in methods:
# method_uuid = method[0]
# method_name = method[1]
# method_detail = method[2]
# method_entry = method[3]
# if method_entry is not None and '测试' not in method_name:
# # Notice the item order
# info.append([method_uuid, method_name, method_detail])
# return info
# --------------------------------- Thread ---------------------------------
def execute_update_task(self):
options = AnalysisTask.OPTION_CALC
if not self.__check_force_calc.isChecked():
options |= AnalysisTask.OPTION_FROM_CACHE
if self.__check_auto_cache.isChecked():
options |= AnalysisTask.OPTION_UPDATE_CACHE
if self.__check_load_json.isChecked():
options |= AnalysisTask.OPTION_LOAD_JSON
if self.__check_dump_json.isChecked():
options |= AnalysisTask.OPTION_DUMP_JSON
if self.__check_load_dump_all.isChecked():
options |= AnalysisTask.OPTION_LOAD_DUMP_ALL
if self.__check_attach_basic_index.isChecked():
options |= AnalysisTask.OPTION_ATTACH_BASIC_INDEX
time_serial = (to_py_datetime(self.__datetime_time_since.dateTime()),
to_py_datetime(self.__datetime_time_until.dateTime()))
self.__timing_clock.reset()
task = AnalysisTask(self, self.__strategy_entry, self.__data_hub_entry,
self.__selector_list, self.__analyzer_list,
time_serial, options, self.__result_output,
self.__progress_rate)
StockAnalysisSystem().get_task_queue().append_task(task)
# if self.__task_thread is None:
# self.__task_thread = threading.Thread(target=self.ui_task)
# StockAnalysisSystem().lock_sys_quit()
# self.__timing_clock.reset()
# self.__task_thread.start()
# else:
# print('Task already running...')
# QMessageBox.information(self,
# QtCore.QCoreApplication.translate('', '无法执行'),
# QtCore.QCoreApplication.translate('', '已经有策略在运行中，无法同时运行多个策略'),
# QMessageBox.Close, QMessageBox.Close)
# def ui_task(self):
# print('Strategy task start.')
#
# self.__lock.acquire()
# selector_list = self.__selector_list
# analyzer_list = self.__analyzer_list
# output_path = self.__result_output
# self.__lock.release()
#
# data_utility = self.__data_hub_entry.get_data_utility()
# stock_list = data_utility.get_stock_identities()
#
# self.__progress_rate.reset()
#
# # ------------- Run analyzer -------------
# clock = Clock()
#
# # result = self.__strategy_entry.run_strategy(stock_list, analyzer_list, progress=self.__progress_rate)
#
# total_result = []
# uncached_analyzer = []
#
# for analyzer in analyzer_list:
# result = self.__strategy_entry.result_from_cache('Result.Analyzer', analyzer=analyzer)
# if result is None or len(result) == 0:
# uncached_analyzer.append(analyzer)
# result = self.__strategy_entry.run_strategy(stock_list, [analyzer], progress=self.__progress_rate)
# else:
# self.__progress_rate.finish_progress(analyzer)
# if result is not None and len(result) > 0:
# total_result.extend(result)
#
# # DEBUG: Load result from json file
# # result = None
# # with open('analysis_result.json', 'rt') as f:
# # result = analysis_results_from_json(f)
# # if result is None:
# # return
#
# print('Analysis time spending: ' + str(clock.elapsed_s()) + ' s')
#
# # # DEBUG: Dump result to json file
# # with open('analysis_result.json', 'wt') as f:
# # analysis_results_to_json(result, f)
#
# # self.__strategy_entry.cache_analysis_result('Result.Analyzer', result)
# result2 = self.__strategy_entry.result_from_cache('Result.Analyzer')
# print(result2)
#
# result = analysis_result_dataframe_to_list(result2)
# print(result)
#
# # ------------ Parse to Table ------------
#
# result_table = analysis_result_list_to_analyzer_security_table(result)
#
# # ----------- Generate report ------------
# clock.reset()
# stock_list = self.__data_hub_entry.get_data_utility().get_stock_list()
# stock_dict = {_id: _name for _id, _name in stock_list}
# name_dict = self.__strategy_entry.strategy_name_dict()
# generate_analysis_report(result_table, output_path, name_dict, stock_dict)
# print('Generate report time spending: ' + str(clock.elapsed_s()) + ' s')
#
# # ----------------- End ------------------
# self.task_finish_signal.emit()
# print('Update task finished.')
# ---------------------------------------------------------------------------------
def notify_task_done(self):
self.task_finish_signal.emit()
def __on_task_done(self):
StockAnalysisSystem().release_sys_quit()
QMessageBox.information(
self, QtCore.QCoreApplication.translate('main', '远行完成'),
QtCore.QCoreApplication.translate(
'main', '策略运行完成，耗时' + str(self.__timing_clock.elapsed_s()) +
'秒\n' + '报告生成路径：' + self.__result_output), QMessageBox.Ok,
QMessageBox.Ok)
class StockMemoEditor(QDialog):
def __init__(self,
sas: StockAnalysisSystem,
memo_record: RecordSet,
parent: QWidget = None):
super(StockMemoEditor, self).__init__(parent)
self.__sas = sas
self.__memo_recordset = memo_record
self.__current_stock = None
self.__current_index = None
self.__current_record: Record = None
data_utility = self.__sas.get_data_hub_entry().get_data_utility(
) if self.__sas is not None else None
self.__combo_stock = SecuritiesSelector(data_utility)
self.__table_memo_index = EasyQTableWidget()
self.__datetime_time = QDateTimeEdit(QDateTime().currentDateTime())
self.__line_brief = QLineEdit()
self.__text_record = QTextEdit()
self.__button_new = QPushButton('新建')
self.__button_apply = QPushButton('保存')
self.init_ui()
self.config_ui()
def init_ui(self):
root_layout = QHBoxLayout()
self.setLayout(root_layout)
group_box, group_layout = create_v_group_box('')
group_layout.addWidget(self.__combo_stock, 1)
group_layout.addWidget(self.__table_memo_index, 99)
root_layout.addWidget(group_box, 4)
group_box, group_layout = create_v_group_box('')
group_layout.addLayout(
horizon_layout(
[QLabel('时间：'), self.__datetime_time, self.__button_new],
[1, 99, 1]))
group_layout.addLayout(
horizon_layout([QLabel('摘要：'), self.__line_brief], [1, 99]))
group_layout.addWidget(self.__text_record)
group_layout.addLayout(
horizon_layout([QLabel(''), self.__button_apply], [99, 1]))
root_layout.addWidget(group_box, 6)
self.setMinimumSize(500, 600)
def config_ui(self):
self.setWindowTitle('笔记编辑器')
self.__datetime_time.setCalendarPopup(True)
self.__combo_stock.setEditable(False)
self.__combo_stock.currentIndexChanged.connect(
self.on_combo_select_changed)
self.__table_memo_index.insertColumn(0)
self.__table_memo_index.insertColumn(0)
self.__table_memo_index.setHorizontalHeaderLabels(['时间', '摘要'])
self.__table_memo_index.setSelectionMode(
QAbstractItemView.SingleSelection)
self.__table_memo_index.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.__table_memo_index.itemSelectionChanged.connect(
self.on_table_selection_changed)
self.__table_memo_index.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.__button_new.clicked.connect(self.on_button_new)
self.__button_apply.clicked.connect(self.on_button_apply)
# self.setWindowFlags(
# QtCore.Qt.Window |
# QtCore.Qt.CustomizeWindowHint |
# QtCore.Qt.WindowTitleHint |
# QtCore.Qt.WindowCloseButtonHint |
# QtCore.Qt.WindowStaysOnTopHint
# )
def on_button_new(self):
if self.__current_stock is None:
QMessageBox.information(self, '错误', '请选择需要做笔记的股票', QMessageBox.Ok,
QMessageBox.Ok)
self.create_new_memo(None)
def on_button_apply(self):
_time = self.__datetime_time.dateTime().toPyDateTime()
brief = self.__line_brief.text()
content = self.__text_record.toPlainText()
if not str_available(brief):
QMessageBox.information(self, '错误', '请至少填写笔记摘要', QMessageBox.Ok,
QMessageBox.Ok)
return
if self.__current_index is not None:
ret = self.__current_record.update_record(self.__current_index,
_time, brief, content,
True)
else:
ret, index = self.__current_record.add_record(
_time, brief, content, 'memo', True)
self.__current_index = index
if ret:
self.__reload_stock_memo()
def on_combo_select_changed(self):
input_securities = self.__combo_stock.get_input_securities()
self.__load_stock_memo(input_securities)
def on_table_selection_changed(self):
if self.__current_record is None:
return
sel_index = self.__table_memo_index.GetCurrentIndex()
if sel_index < 0:
return
sel_item = self.__table_memo_index.item(sel_index, 0)
if item is None:
return
df_index = sel_item.data(Qt.UserRole)
self.__load_memo_by_index(df_index)
def select_stock(self, stock_identity: str):
index = self.__combo_stock.findData(stock_identity)
if index != -1:
print('Select combox index: %s' % index)
self.__combo_stock.setCurrentIndex(index)
else:
print('No index in combox for %s' % stock_identity)
self.__combo_stock.setCurrentIndex(-1)
self.__load_stock_memo(stock_identity)
def select_memo_by_time(self, _time: datetime.datetime):
if self.__current_record is None or self.__current_record.is_empty():
self.create_new_memo(_time)
return
df = self.__current_record.get_records('memo')
time_serial = df['time'].dt.normalize()
select_df = df[time_serial == _time.replace(
hour=0, minute=0, second=0, microsecond=0)]
select_index = None
for index, row in select_df.iterrows():
select_index = index
break
if select_index is not None:
self.select_memo_by_index(select_index)
else:
self.create_new_memo(_time)
def select_memo_by_index(self, index: int):
for row in range(0, self.__table_memo_index.rowCount()):
table_item = self.__table_memo_index.item(row, 0)
row_index = table_item.data(Qt.UserRole)
if row_index == index:
self.__table_memo_index.selectRow(row)
break
def create_new_memo(self, _time: datetime.datetime):
self.__table_memo_index.clearSelection()
if _time is not None:
self.__datetime_time.setDateTime(_time)
self.__line_brief.setText('')
self.__text_record.setText('')
self.__current_index = None
# -------------------------------------------------------------------
def __load_stock_memo(self, stock_identity: str):
print('Load stock memo for %s' % stock_identity)
self.__table_memo_index.clear()
self.__table_memo_index.setRowCount(0)
self.__table_memo_index.setHorizontalHeaderLabels(['时间', '摘要'])
self.__current_stock = stock_identity
self.__current_record = None
self.__current_index = None
if self.__memo_recordset is None or \
self.__current_stock is None or self.__current_stock == '':
return
self.__current_record = self.__memo_recordset.get_record(
stock_identity)
df = self.__current_record.get_records('memo')
select_index = None
for index, row in df.iterrows():
if select_index is None:
select_index = index
self.__table_memo_index.AppendRow(
[datetime2text(row['time']), row['brief']], index)
self.select_memo_by_index(select_index)
def __reload_stock_memo(self):
self.__line_brief.setText('')
self.__text_record.setText('')
self.__table_memo_index.clear()
self.__table_memo_index.setRowCount(0)
self.__table_memo_index.setHorizontalHeaderLabels(['时间', '摘要'])
if self.__current_record is None:
print('Warning: Current record is None, cannot reload.')
return
df = self.__current_record.get_records('memo')
select_index = self.__current_index
for index, row in df.iterrows():
if select_index is None:
select_index = index
self.__table_memo_index.AppendRow(
[datetime2text(row['time']), row['brief']], index)
self.select_memo_by_index(select_index)
def __load_memo_by_index(self, index: int):
self.__table_memo_index.clearSelection()
if self.__current_record is None or index is None:
return
df = self.__current_record.get_records('memo')
s = df.loc[index]
if len(s) == 0:
return
self.__current_index = index
_time = s['time']
brief = s['brief']
content = s['content']
self.__datetime_time.setDateTime(to_py_datetime(_time))
self.__line_brief.setText(brief)
self.__text_record.setText(content)
class MainWindow(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.files = files.get_files()
self.height = 300
self.checkboxes = []
self.col_selects = []
self.initUI()
def initUI(self):
self.layout = QVBoxLayout()
pic = QLabel()
pic.setPixmap(QPixmap(os.getcwd() + "/logo3.jpg"))
self.layout.addWidget(pic)
self.flash_msg = QLabel("")
self.flash_msg.setStyleSheet("QLabel { color : red; }")
self.layout.addWidget(self.flash_msg)
self.flash_msg.hide()
self.layout.addWidget(QLabel("Wähle Größen:"))
for file in self.files:
checkbox = QCheckBox()
text = "{} ({})".format(str(file), file.unit)
checkbox.setText(text)
self.layout.addWidget(checkbox)
self.checkboxes.append(checkbox)
col_select = Col_select(file.columns)
col_select.hide()
self.col_selects.append(col_select)
self.layout.addWidget(col_select)
checkbox.stateChanged.connect(self.toggle_checkbox(col_select))
self._set_date_time_edit()
button = QPushButton("Weiter")
button.clicked.connect(self.plot)
self.layout.addWidget(button)
self.setGeometry(300, 300, 200, self.height)
self.setLayout(self.layout)
self.setWindowTitle('Csv Plotter')
self.show()
def _set_date_time_edit(self):
gridLayout = QGridLayout()
self.start = QDateTimeEdit()
self.end = QDateTimeEdit()
gridLayout.addWidget(QLabel("Startzeit"), 0, 0)
gridLayout.addWidget(self.start, 0, 1)
gridLayout.addWidget(QLabel("Endzeit"), 1, 0)
gridLayout.addWidget(self.end, 1, 1)
self.layout.addLayout(gridLayout)
def _check_submission(self, files_, columns):
"checks if submit is valid, shows error message if not"
msg = ""
for idx, col in enumerate(columns):
if col == []:
msg = ("Bitte eine Größe zu folgender Kategorie auswählen: {}"
.format(files_[idx].quantity))
if len(set((file.unit for file in files_))) != 1:
msg = "Die Ausgewählten Größen haben unterschiedliche Einheiten."
if msg:
self.flash_msg.setText(msg)
self.flash_msg.show()
return False
self.flash_msg.hide()
return True
def plot(self):
files_and_columns = [(file, col_select) for file, checkbox, col_select
in zip(self.files, self.checkboxes, self.col_selects)
if checkbox.isChecked()]
files_ = [file for file, col in files_and_columns]
columns = [col.get_selected() for file, col in files_and_columns]
if not self._check_submission(files_, columns):
return
files.plot_files(self.start.dateTime().toPyDateTime(),
self.end.dateTime().toPyDateTime(), files_, columns)
def _set_start(self, py_datetime):
qt_datetime = _datetime_to_Qdatetime(py_datetime)
if self.start.dateTime() < qt_datetime:
self.start.setDateTime(qt_datetime)
def _set_end(self, py_datetime):
qt_datetime = _datetime_to_Qdatetime(py_datetime)
default = QDateTime.fromString("2000-01-01 00:00:00,0" , "yyyy-MM-dd HH:mm:ss,z")
if self.end.dateTime() > qt_datetime or self.end.dateTime() == default:
self.end.setDateTime(qt_datetime)
def toggle_checkbox(self, cb):
"expand or collapse more options"
def wrapped():
cb.show() if cb.isHidden() else cb.hide()
self.height += 100 if cb.isHidden() else - 100
self.resize(200, self.height)
file_ind = self.col_selects.index(cb)
file = self.files[file_ind]
self._set_start(file.start)
self._set_end(file.end)
return wrapped
class LogFilterDialog(QDialog):
OPERATION_OPTIONS = ['', 'insert', 'delete']
TABLENAME_OPTIONS = ['', 'blocks', 'devices', 'measurements',\
'raw_data_view']
def __init__(self, parent=None):
super(LogFilterDialog, self).__init__(parent)
self.accepted.connect(self.createFilter)
self.operationCombo = QComboBox()
self.operationCombo.addItems(LogFilterDialog.OPERATION_OPTIONS)
self.tablenameCombo = QComboBox()
self.tablenameCombo.addItems(LogFilterDialog.TABLENAME_OPTIONS)
self.fromEdit = QDateTimeEdit()
self.toEdit = QDateTimeEdit()
groupLayout = QFormLayout()
groupLayout.addRow("Od: ", self.fromEdit)
groupLayout.addRow("Do: ", self.toEdit)
groupLayout.addRow("Operace: ", self.operationCombo)
groupLayout.addRow("Tabulka: ", self.tablenameCombo)
rejectButton = QPushButton("Storno")
rejectButton.clicked.connect(self.reject)
acceptButton = QPushButton("OK")
acceptButton.clicked.connect(self.accept)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(acceptButton)
buttonsLayout.addWidget(rejectButton)
layout = QVBoxLayout()
layout.addLayout(groupLayout)
layout.addSpacing(12)
layout.addLayout(buttonsLayout)
self.setLayout(layout)
self.setMinimumWidth(300)
self.setWindowTitle("Filtrování logů")
def initControls(self, filter_):
selected = filter_.get('operation', '')
try:
index = LogFilterDialog.OPERATION_OPTIONS.index(selected)
except ValueError:
index = 0
self.operationCombo.setCurrentIndex(index)
selected = filter_.get('tablename', '')
try:
index = LogFilterDialog.TABLENAME_OPTIONS.index(selected)
except ValueError:
index = 0
self.tablenameCombo.setCurrentIndex(index)
start = filter_.get('start_datetime', None)
if start is None:
start = datetime.utcnow()
start = calendar.timegm(start.timetuple()) - 3600*24
else:
start = calendar.timegm(start.timetuple())
end = filter_.get('end_datetime', datetime.utcnow())
end = calendar.timegm(end.timetuple())
self.fromEdit.setDateTime(QDateTime.fromTime_t(start, TZ))
self.toEdit.setDateTime(QDateTime.fromTime_t(end, TZ))
def getFilter(self):
filter_ = {}
start = self.fromEdit.dateTime().toTime_t()
end = self.toEdit.dateTime().toTime_t()
filter_['start_datetime'] = datetime.utcfromtimestamp(start)
filter_['end_datetime'] = datetime.utcfromtimestamp(end)
if self.operationCombo.currentText():
filter_['operation'] = self.operationCombo.currentText()
if self.tablenameCombo.currentText():
filter_['tablename'] = self.tablenameCombo.currentText()
return filter_
@pyqtSlot()
def createFilter(self):
self._filter = self.getFilter()
def filter(self):
return self._filter
class Ui_MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.transprot_mass =[]
self.netprot_mass =[]
self.filtering_is_on = 0
grid = QGridLayout()
self.setLayout(grid)
self.IP_list = IP_list(self)
self.TransProt_list = TransProt_list(self)
self.NetProt_list = NetProt_list(self)
self.setWindowTitle('Гамма')
self.setWindowIcon(QIcon('допочки\Gamma_200x200.png'))
self.resize(740, 830)
self.to_center()
self.centralwidget = QWidget(self)
self.tabWidget = QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(QRect(20, 20, 700, 750))
self.tab = QWidget()
grid.addWidget(self.tab)
self.cb_time = QCheckBox(self.tab)
self.cb_time.setGeometry(QRect(360, 130, 120, 20))
self.cb_time.setText("Фильтр по времени")
self.cb_prot = QCheckBox(self.tab)
self.cb_prot.setGeometry(QRect(20, 130, 140, 20))
self.cb_prot.setText("Фильтр по протоколам")
self.cb_addr = QCheckBox(self.tab)
self.cb_addr.setGeometry(QRect(360, 290, 130, 20))
self.cb_addr.setText("Фильтр по IP-адресам")
self.dt_beg = QDateTimeEdit(self.tab)
self.dt_beg.setGeometry(QRect(360, 210, 150, 20))
self.dt_beg.setDateTime(QDateTime.currentDateTime())
self.dt_beg.setDisplayFormat("dd.MM.yyyy H:mm:ss.zzz")
self.dt_beg.setCalendarPopup(True)
self.dt_beg.setToolTip('Выбрать начальное время (>=)')
self.dt_beg.setEnabled(False)
self.dt_end = QDateTimeEdit(self.tab)
self.dt_end.setGeometry(QRect(520, 210, 150, 20))
self.dt_end.setDateTime(QDateTime.currentDateTime())
self.dt_end.setDisplayFormat("dd.MM.yyyy H:mm:ss.zzz")
self.dt_end.setCalendarPopup(True)
self.dt_end.setToolTip('Выбрать конечное время (<)')
self.dt_end.setEnabled(False)
self.dt_beg.dateChanged.connect(lambda dc: self.date_changed(1))
self.dt_end.dateChanged.connect(lambda dc: self.date_changed(2))
#self.l_input_dir = QLabel(self.tab)
#self.l_input_dir.setGeometry(QRect(102, 50, 180, 15))
#self.l_input_dir.setText("Выберите директорию с файлами")
#self.l_or = QLabel(self.tab)
#self.l_or.setGeometry(QRect(340, 50, 21, 16))
#self.l_or.setText("ИЛИ")
self.l_input_file = QLabel(self.tab)
self.l_input_file.setGeometry(QRect(300, 50, 90, 15))
self.l_input_file.setText("Выберите файлы")
self.l_transpr = QLabel(self.tab)
self.l_transpr.setGeometry(QRect(50, 190, 180, 16))
self.l_transpr.setEnabled(False)
self.l_transpr.setText("Протоколы Транспортного уровня")
self.l_netpr = QLabel(self.tab)
self.l_netpr.setGeometry(QRect(50, 290, 180, 16))
self.l_netpr.setEnabled(False)
self.l_netpr.setText("Протоколы Сетевого уровня")
self.l_beg = QLabel(self.tab)
self.l_beg.setGeometry(QRect(390, 190, 60, 16))
self.l_beg.setEnabled(False)
self.l_beg.setText("Начиная с..")
self.l_end = QLabel(self.tab)
self.l_end.setGeometry(QRect(560, 190, 80, 16))
self.l_end.setEnabled(False)
self.l_end.setText("Оканчивая до..")
self.l_name = QLabel(self.tab)
self.l_name.setGeometry(QRect(300, 450, 96, 16))
self.l_name.setText("Как назвать файл?")
self.l_filt = QLabel(self.tab)
self.l_filt.setGeometry(QRect(300, 10, 91, 16))
self.l_filt.setText("Выборка пакетов")
self.line = QFrame(self.tab)
self.line.setGeometry(QRect(0, 110, 690, 15))
self.line.setFrameShape(QFrame.HLine)
self.line.setFrameShadow(QFrame.Sunken)
self.line_2 = QFrame(self.tab)
self.line_2.setGeometry(QRect(340, 120, 15, 300))
self.line_2.setFrameShape(QFrame.VLine)
self.line_2.setFrameShadow(QFrame.Sunken)
self.line_3 = QFrame(self.tab)
self.line_3.setGeometry(QRect(0, 420, 690, 15))
self.line_3.setFrameShape(QFrame.HLine)
self.line_3.setFrameShadow(QFrame.Sunken)
#self.le_dir = QLineEdit(self.tab)
#self.le_dir.setGeometry(QRect(110, 80, 211, 20))
#self.le_dir.setEnabled(False)
#self.le_dir.setReadOnly(True)
self.le_file = QLineEdit(self.tab)
self.le_file.setGeometry(QRect(250, 80, 211, 20))
#self.le_file.setEnabled(False)
self.le_file.setReadOnly(True)
self.le_name = QLineEdit(self.tab)
self.le_name.setGeometry(QRect(250, 480, 231, 20))
self.pt_transpr = QPlainTextEdit(self.tab)
self.pt_transpr.setGeometry(QRect(50, 210, 271, 71))
self.pt_transpr.setEnabled(False)
self.pt_transpr.setReadOnly(True)
self.pt_netpr = QPlainTextEdit(self.tab)
self.pt_netpr.setGeometry(QRect(50, 320, 271, 71))
self.pt_netpr.setEnabled(False)
self.pt_netpr.setReadOnly(True)
self.pt_addr = QPlainTextEdit(self.tab)
self.pt_addr.setGeometry(QRect(390, 320, 271, 71))
self.pt_addr.setEnabled(False)
self.pt_log = QPlainTextEdit(self.tab)
self.pt_log.setGeometry(QRect(20, 610, 651, 101))
self.pt_log.setReadOnly(True)
self.progressBar = QProgressBar(self.tab)
self.progressBar.setGeometry(QRect(20, 580, 651, 20))
self.progressBar.setFormat("%v" + "%")
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
#self.pb_dir = QPushButton(self.tab)
#self.pb_dir.setGeometry(QRect(80, 80, 21, 20))
#self.pb_dir.setIcon(QIcon('допочки\_folder.png'))
#self.pb_dir.clicked.connect(lambda gd: self.get_directory(1))
self.pb_file = QPushButton(self.tab)
self.pb_file.setGeometry(QRect(220, 80, 21, 20))
self.pb_file.setIcon(QIcon('допочки\_folder.png'))
self.pb_file.clicked.connect(lambda gf: self.get_files(1))
self.pb_time = QPushButton(self.tab)
self.pb_time.setGeometry(QRect(480, 240, 71, 20))
self.pb_time.setToolTip('Добавить ещё временной отрезок')
self.pb_time.setEnabled(False)
self.pb_time.setText("Ещё!")
self.pb_transpr = QPushButton(self.tab)
self.pb_transpr.setGeometry(QRect(20, 210, 21, 20))
self.pb_transpr.setToolTip('Выбрать протоколы Транспортного уровня')
self.pb_transpr.setIcon(QIcon('допочки\_blank.png'))
self.pb_transpr.setEnabled(False)
self.pb_transpr.clicked.connect(self.TransProt_list.exec)
self.pb_netpr = QPushButton(self.tab)
self.pb_netpr.setGeometry(QRect(20, 320, 21, 20))
self.pb_netpr.setToolTip('Выбрать протоколы Сетевого уровня')
self.pb_netpr.setIcon(QIcon('допочки\_blank.png'))
self.pb_netpr.setEnabled(False)
self.pb_netpr.clicked.connect(self.NetProt_list.exec)
self.pb_addr = QPushButton(self.tab)
self.pb_addr.setGeometry(QRect(530, 290, 132, 20))
self.pb_addr.setText('Редактировать список')
self.pb_addr.setEnabled(False)
self.pb_addr.clicked.connect(self.IP_list.exec)
self.pb_name = QPushButton(self.tab)
self.pb_name.setGeometry(QRect(220, 480, 21, 20))
self.pb_name.setIcon(QIcon('допочки\_folder.png'))
self.pb_name.clicked.connect(lambda ed: self.extract_to_directory(1))
self.pb_start = QPushButton(self.tab)
self.pb_start.setGeometry(QRect(220, 510, 261, 41))
self.pb_start.setText("Начать выборку")
self.pb_start.clicked.connect(self.do_it_motherFucker)
#self.radiobutton = QRadioButton(self.tab)
#self.radiobutton.setGeometry(QRect(84, 48, 20, 20))
#self.radiobutton_2 = QRadioButton(self.tab)
#self.radiobutton_2.setGeometry(QRect(424, 48, 20, 20))
#self.radiobutton.raise_()
#self.radiobutton_2.raise_()
self.cb_time.raise_()
self.cb_prot.raise_()
self.cb_addr.raise_()
self.dt_beg.raise_()
self.dt_end.raise_()
#self.l_input_dir.raise_()
#self.l_or.raise_()
self.l_input_file.raise_()
self.l_transpr.raise_()
self.l_netpr.raise_()
self.l_beg.raise_()
self.l_end.raise_()
self.l_name.raise_()
self.l_filt.raise_()
self.line.raise_()
self.line_2.raise_()
self.line_3.raise_()
#self.le_dir.raise_()
self.le_file.raise_()
self.le_name.raise_()
self.pt_transpr.raise_()
self.pt_netpr.raise_()
self.pt_addr.raise_()
self.pt_log.raise_()
self.progressBar.raise_()
#self.pb_dir.raise_()
self.pb_file.raise_()
self.pb_time.raise_()
self.pb_transpr.raise_()
self.pb_netpr.raise_()
self.pb_addr.raise_()
self.pb_name.raise_()
self.pb_start.raise_()
self.setCentralWidget(self.centralwidget)
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.tabWidget.addTab(self.tab, "")
self.cb_time.clicked['bool'].connect(self.dt_beg.setEnabled)
self.cb_time.clicked['bool'].connect(self.dt_end.setEnabled)
self.cb_time.clicked['bool'].connect(self.l_beg.setEnabled)
self.cb_time.clicked['bool'].connect(self.l_end.setEnabled)
self.cb_prot.clicked['bool'].connect(self.l_transpr.setEnabled)
self.cb_prot.clicked['bool'].connect(self.l_netpr.setEnabled)
self.cb_prot.clicked['bool'].connect(self.pt_transpr.setEnabled)
self.cb_prot.clicked['bool'].connect(self.pt_netpr.setEnabled)
self.cb_prot.clicked['bool'].connect(self.pb_transpr.setEnabled)
self.cb_prot.clicked['bool'].connect(self.pb_netpr.setEnabled)
self.cb_addr.clicked['bool'].connect(self.pt_addr.setEnabled)
self.cb_addr.clicked['bool'].connect(self.pb_addr.setEnabled)
#####------------------------------2_TAB
self.tab_2 = QWidget()
self.tabWidget.addTab(self.tab_2, "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), ("II работа с файлами"))
self.l_merge = QLabel(self.tab_2)
self.l_merge.setGeometry(QRect(300, 10, 180, 16))
self.l_merge.setText("Объединение файлов")
self.l_arch = QLabel(self.tab_2)
self.l_arch.setGeometry(QRect(300, 250, 180, 16))
self.l_arch.setText("Архивирование файлов")
#self.radiobutton_3 = QRadioButton(self.tab_2)
#self.radiobutton_3.setGeometry(QRect(84, 48, 20, 20))
#self.radiobutton_4 = QRadioButton(self.tab_2)
#self.radiobutton_4.setGeometry(QRect(424, 48, 20, 20))
#self.l_input_dir2 = QLabel(self.tab_2)
#self.l_input_dir2.setGeometry(QRect(102, 50, 180, 15))
#self.l_input_dir2.setText("Выберите директорию с файлами")
#self.l_or2 = QLabel(self.tab_2)
#self.l_or2.setGeometry(QRect(340, 50, 21, 16))
#self.l_or2.setText("ИЛИ")
self.l_input_file2 = QLabel(self.tab_2)
self.l_input_file2.setGeometry(QRect(102, 50, 180, 15))#442, 50, 90, 15))
self.l_input_file2.setText("Выберите файлы")
self.l_name2 = QLabel(self.tab_2)
self.l_name2.setGeometry(QRect(442, 50, 180, 15))#280, 140, 180, 16))
self.l_name2.setText("Куда сохранить результат?")
self.l_ciph2 = QLabel(self.tab_2)
self.l_ciph2.setGeometry(QRect(84, 298, 180, 15))
self.l_ciph2.setText("Убрать шифрованный трафик")
self.l_arch2 = QLabel(self.tab_2)
self.l_arch2.setGeometry(QRect(424, 298, 180, 15))
self.l_arch2.setText("Заархивировать файлы")
#self.le_dir2 = QLineEdit(self.tab_2)
#self.le_dir2.setGeometry(QRect(110, 80, 211, 20))
#self.le_dir2.setEnabled(False)
self.le_file2 = QLineEdit(self.tab_2)
self.le_file2.setGeometry(QRect(110, 80, 211, 20))#450, 80, 211, 20))
self.le_file2.setReadOnly(True)
self.le_name2 = QLineEdit(self.tab_2)
self.le_name2.setGeometry(QRect(450, 80, 211, 20))#260, 170, 180, 20))
#self.pb_dir2 = QPushButton(self.tab_2)
#self.pb_dir2.setGeometry(QRect(80, 80, 21, 20))
#self.pb_dir2.setIcon(QIcon('допочки\_folder.png'))
#self.pb_dir2.clicked.connect(lambda gd: self.get_directory(2))
self.pb_file2 = QPushButton(self.tab_2)
self.pb_file2.setGeometry(QRect(80, 80, 21, 20))#420, 80, 21, 20))
self.pb_file2.setIcon(QIcon('допочки\_folder.png'))
self.pb_file2.clicked.connect(lambda gf: self.get_files(2))
self.pb_name2 = QPushButton(self.tab_2)
self.pb_name2.setGeometry(QRect(420, 80, 21, 20))#230, 170, 21, 20))
self.pb_name2.setIcon(QIcon('допочки\_folder.png'))
self.pb_name2.clicked.connect(lambda ed: self.extract_to_directory(2))
self.pb_merge = QPushButton(self.tab_2)
self.pb_merge.setGeometry(QRect(270, 170, 160, 20))
self.pb_merge.setText("Объединить")
self.pb_merge.clicked.connect(self.merge_it_motherFucker)
self.line_4 = QFrame(self.tab_2)
self.line_4.setGeometry(QRect(0, 280, 690, 15))
self.line_4.setFrameShape(QFrame.HLine)
self.line_4.setFrameShadow(QFrame.Sunken)
self.line_5 = QFrame(self.tab_2)
self.line_5.setGeometry(QRect(0, 580, 690, 15))
self.line_5.setFrameShape(QFrame.HLine)
self.line_5.setFrameShadow(QFrame.Sunken)
self.pt_log2 = QPlainTextEdit(self.tab_2)
self.pt_log2.setGeometry(QRect(20, 610, 651, 101))
self.pt_log2.setReadOnly(True)
self.graphicsView = QGraphicsView(self.tab_2)
self.graphicsView.setGeometry(QRect(0, 330, 714, 277))
self.scene = QGraphicsScene()
self.graphicsView.setScene(self.scene)
self.scene.addPixmap(QPixmap('допочки\_in_working_3.png'))
self.l_merge.raise_()
self.l_arch.raise_()
#self.l_input_dir2.raise_()
#self.l_or2.raise_()
self.l_input_file2.raise_()
self.l_name2.raise_()
#self.radiobutton_3.raise_()
#self.radiobutton_4.raise_()
#self.pb_dir2.raise_()
self.pb_file2.raise_()
self.pb_name2.raise_()
#self.le_dir2.raise_()
self.le_file2.raise_()
self.le_name2.raise_()
self.line_4.raise_()
self.line_5.raise_()
self.pt_log2.raise_()
#####------------------------------2_TAB
#####------------------------------3_TAB
self.tab_3 = QWidget()
self.tabWidget.addTab(self.tab_3, "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3), ("III Проверка на аномальную активность"))
self.tab_3.setEnabled(False)
self.l_filt3 = QLabel(self.tab_3)
self.l_filt3.setGeometry(QRect(300, 10, 91, 16))
self.l_filt3.setText("Выборка пакетов")
self.l_input_file3 = QLabel(self.tab_3)
self.l_input_file3.setGeometry(QRect(300, 50, 90, 15))
self.l_input_file3.setText("Выберите файлы")
self.pb_file3 = QPushButton(self.tab_3)
self.pb_file3.setGeometry(QRect(220, 80, 21, 20))
self.pb_file3.setIcon(QIcon('допочки\_folder.png'))
self.pb_file3.clicked.connect(lambda gf: self.get_files(3))
self.le_file3 = QLineEdit(self.tab_3)
self.le_file3.setGeometry(QRect(250, 80, 211, 20))
self.le_file3.setReadOnly(True)
self.pb_graphy = QPushButton(self.tab_3)
self.pb_graphy.setGeometry(QRect(270, 170, 160, 20))
self.pb_graphy.setText("Построить граф")
#self.pb_graphy.clicked.connect(self.graph_it)
#self.label_6 = QLabel(self.tab_3)
#self.pixmap = QPixmap('допочки\_in_working_1.png')
#self.label_6.setPixmap(self.pixmap)
self.l_filt3.raise_()
self.l_input_file3.raise_()
self.pb_file3.raise_()
self.le_file3.raise_()
#####------------------------------3_TAB
#####----------------------------IN_WORK
self.tab_4 = QWidget()
self.tabWidget.addTab(self.tab_4, "")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_4), ("...IV visualization..."))
self.tab_4.setEnabled(False)
self.label_7 = QLabel(self.tab_4)
self.pixmap_2 = QPixmap('допочки\_in_working_2.png')
self.label_7.setPixmap(self.pixmap_2)
#####----------------------------IN_WORK
self.tabWidget.setCurrentIndex(0)
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), ("I выборка пакетов"))
QMetaObject.connectSlotsByName(self)
self.show()
def closeEvent(self, event):
reply = QMessageBox.question(self, 'Ща закроется всё', "Ты чо, реально хочешь выйти?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def to_center(self):
qr = self.frameGeometry()
qr.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(qr.topLeft())
def get_directory(self, gd):
if gd == 1:
result = QFileDialog.getExistingDirectory()
#self.le_dir.setText(result)
self.le_file.setDisabled(True)
#self.le_dir.setEnabled(True)
#self.radiobutton_2.setChecked(False)
#self.radiobutton.setChecked(True)
else:
result = QFileDialog.getExistingDirectory()
#self.le_dir2.setText(result)
self.le_file2.setDisabled(True)
#self.le_dir2.setEnabled(True)
#self.radiobutton_4.setChecked(False)
#self.radiobutton_3.setChecked(True)
def get_files(self, gf):
if gf == 1:
result, bullshit = QFileDialog.getOpenFileNames(self, "Выберите pcap-файлы", getcwd(), "files (*.pcap *.pcapng)")
#self.le_dir.setDisabled(True)
self.le_file.setEnabled(True)
#self.radiobutton.setChecked(False)
#self.radiobutton_2.setChecked(True)
if len(result):
self.le_file.setText(", ".join(result))
elif gf == 3:
result, bullshit = QFileDialog.getOpenFileNames(self, "Выберите pcap-файлы", getcwd(), "files (*.pcap *.pcapng)")
#self.le_dir.setDisabled(True)
self.le_file3.setEnabled(True)
#self.radiobutton.setChecked(False)
#self.radiobutton_2.setChecked(True)
if len(result):
self.le_file3.setText(", ".join(result))
else:
result, bullshit = QFileDialog.getOpenFileNames(self, "Выберите pcap-файлы", getcwd(), "files (*.pcap *.pcapng)")
#self.le_dir2.setDisabled(True)
self.le_file2.setEnabled(True)
#self.radiobutton_3.setChecked(False)
#self.radiobutton_4.setChecked(True)
if len(result):
self.le_file2.setText(", ".join(result))
def date_changed(self, dc):
if dc == 1:
self.dt_end.setMinimumDateTime(QDateTime(self.dt_beg.dateTime()))
else:
self.dt_beg.setMaximumDateTime(QDateTime(self.dt_end.dateTime()))
def extract_to_directory(self, ed):
if ed == 1:
result, bullshit =QFileDialog.getSaveFileName(self, "Сохранить файл", getcwd(), "files (*.pcap *.pcapng)")
self.le_name.setText(result)
else:
result, bullshit =QFileDialog.getSaveFileName(self, "Сохранить файл", getcwd(), "files (*.pcap *.pcapng)")
self.le_name2.setText(result)
def do_it_motherFucker(self):
if self.filtering_is_on == 0:
#if ((not self.radiobutton.isChecked() and not self.radiobutton_2.isChecked())\
# or (self.radiobutton.isChecked() and self.le_dir.text() == '')\
# or (self.radiobutton_2.isChecked() and self.le_file.text() == ''))\
# and self.le_name.text() == '':
if self.le_file.text() == '' and self.le_name.text() == '':
self.pt_log.appendPlainText(" " + "Какие файлы обработать? Куда сохранить? Такая неопределённость..")
#elif (not self.radiobutton.isChecked() and not self.radiobutton_2.isChecked()) or (self.radiobutton.isChecked() and self.le_dir.text() == '') or (self.radiobutton_2.isChecked() and self.le_file.text() == ''):
elif self.le_file.text() == '':
self.pt_log.appendPlainText(" " + "Какие файлы обработать?")
elif self.le_name.text() == '':
self.pt_log.appendPlainText(" " + "Куда сохранить?")
else:
self.filtering_is_on = 1 # эти пиздецы в идеале нужно заменить на что-нибудь адекватное
self.count_for_pr_b = 0 # эти пиздецы в идеале нужно заменить на что-нибудь адекватное
self.progressBar.setValue(0)
self.pb_start.setText("Остановить выборку")
#my_directory = self.le_dir.text()
pcap_files_in = self.le_file.text()
pcap_file_out = self.le_name.text()
per_quest = 0
per_beg = ''
per_end = ''
prot_quest = 0
net_prot = 0
trans_prot = 0
appl_prot = 0 ##
ip_quest = 0
netprot_mass = []
transprot_mass = []
addr_mass = []
if (pcap_file_out.endswith(".pcap") or pcap_file_out.endswith(".pcapng")) == False:
pcap_file_out = pcap_file_out + ".pcap"
self.pt_log.appendPlainText("Сохранить в:")
self.pt_log.appendPlainText(" " + pcap_file_out)
#if self.radiobutton.isChecked():
# onlyfiles = [my_directory + '/' + f for f in listdir(my_directory) if
# f.endswith(".pcap") or f.endswith(".pcapng") and isfile(join(my_directory, f))]
# self.for_pr_b = len(onlyfiles)
#
# self.pt_log.appendPlainText("Выбрана директория:")
# self.pt_log.appendPlainText(" " + self.le_dir.text())
# self.pt_log.appendPlainText("С pcap-файлами:")
# for file in onlyfiles:
# bullshit, fname = file.rsplit('/', 1)
# self.pt_log.appendPlainText(" " + fname)
#elif self.radiobutton_2.isChecked():
onlyfiles = pcap_files_in.split(', ')
self.for_pr_b = len(onlyfiles)
self.pt_log.appendPlainText("Выбраны pcap-файлы:")
for file in onlyfiles:
self.pt_log.appendPlainText(" " + (file))
if self.cb_addr.isChecked() and self.pt_addr.toPlainText() != '':
ip_quest = 1
addr_mass = self.pt_addr.toPlainText().splitlines()
if self.cb_time.isChecked():
per_quest = 1
per_beg = self.dt_beg.dateTime()
per_end = self.dt_end.dateTime()
if self.cb_prot.isChecked():
prot_quest = 1
transprot_mass = self.transprot_mass
netprot_mass = self.netprot_mass
if self.pt_transpr.toPlainText() != '':
trans_prot = 1
if self.pt_netpr.toPlainText() != '':
net_prot = 1
#self.radiobutton.setDisabled(True)
#self.radiobutton_2.setDisabled(True)
#self.l_input_dir.setDisabled(True)
#self.l_or.setDisabled(True)
self.l_input_file.setDisabled(True)
#self.pb_dir.setDisabled(True)
self.pb_file.setDisabled(True)
#self.le_dir.setDisabled(True)
self.le_file.setDisabled(True)
self.cb_time.setDisabled(True)
self.cb_prot.setDisabled(True)
self.cb_addr.setDisabled(True)
self.l_transpr.setDisabled(True)
self.l_netpr.setDisabled(True)
self.l_beg.setDisabled(True)
self.l_end.setDisabled(True)
self.l_name.setDisabled(True)
self.l_filt.setDisabled(True)
self.le_name.setDisabled(True)
self.dt_beg.setDisabled(True)
self.dt_end.setDisabled(True)
self.pt_transpr.setDisabled(True)
self.pt_netpr.setDisabled(True)
self.pt_addr.setDisabled(True)
self.pb_time.setDisabled(True)
self.pb_transpr.setDisabled(True)
self.pb_netpr.setDisabled(True)
self.pb_addr.setDisabled(True)
self.pb_name.setDisabled(True)
self.worker = WorkerThread(onlyfiles, pcap_file_out, per_quest, per_beg, per_end, prot_quest, net_prot,
netprot_mass, trans_prot, transprot_mass, appl_prot, ip_quest, addr_mass)
self.worker.callback_received.connect(self.append_to_log)
self.worker.start()
self.pt_log.appendPlainText("")
self.pt_log.appendPlainText("В работе:")
elif self.filtering_is_on == 1:
self.worker.terminate()
self.pt_log.appendPlainText("")
self.pt_log.appendPlainText("Работа прервана")
self.pt_log.appendPlainText("")
self.pt_log.appendPlainText("")
self.go_to_starting_set()
def append_to_log(self, x):
self.count_for_pr_b += 1
self.pt_log.appendPlainText("")
self.pt_log.appendPlainText(x)
self.progressBar.setValue(self.count_for_pr_b * 100 / (self.for_pr_b + 1))
if self.progressBar.value() == 100:
self.pt_log.appendPlainText("")
self.pt_log.appendPlainText("")
self.go_to_starting_set()
def go_to_starting_set(self):
self.filtering_is_on = 0
self.pb_start.setText("Начать выборку")
#self.radiobutton.setDisabled(False)
#self.radiobutton_2.setDisabled(False)
#self.l_input_dir.setDisabled(False)
#self.l_or.setDisabled(False)
self.l_input_file.setDisabled(False)
#self.pb_dir.setDisabled(False)
self.pb_file.setDisabled(False)
#self.le_dir.setDisabled(False)
self.le_file.setDisabled(False)
self.cb_time.setDisabled(False)
self.cb_prot.setDisabled(False)
self.cb_addr.setDisabled(False)
self.l_name.setDisabled(False)
self.l_filt.setDisabled(False)
self.le_name.setDisabled(False)
self.pb_name.setDisabled(False)
if self.cb_time.isChecked():
self.dt_beg.setEnabled(True)
self.dt_end.setEnabled(True)
self.l_beg.setEnabled(True)
self.l_end.setEnabled(True)
if self.cb_prot.isChecked():
self.l_transpr.setEnabled(True)
self.l_netpr.setEnabled(True)
self.pt_transpr.setEnabled(True)
self.pt_netpr.setEnabled(True)
self.pb_transpr.setEnabled(True)
self.pb_netpr.setEnabled(True)
if self.cb_addr.isChecked():
self.pt_addr.setEnabled(True)
self.pb_addr.setEnabled(True)
def merge_it_motherFucker(self):
#if self.radiobutton_3.isChecked():
# self.pt_log2.appendPlainText("Выбрана директория с pcap-файлами:")
# self.pt_log2.appendPlainText(" " + self.le_dir2.text())
# self.pt_log2.appendPlainText('Просматриваем "{}"...'.format(self.le_dir2.text()))
# onlyfiles = [self.le_dir2.text() + '/' + f for f in listdir(self.le_dir2.text()) if
# f.endswith(".pcap") or f.endswith(".pcapng") and isfile(join(self.le_dir2.text(), f))]
# self.pt_log2.appendPlainText(str(onlyfiles))
#elif self.radiobutton_4.isChecked():
self.pt_log2.appendPlainText("Выбраны pcap-файлы:")
self.pt_log2.appendPlainText(" " + self.le_file2.text())
onlyfiles = self.le_file2.text().split(', ')
self.pt_log2.appendPlainText('Работаем с "{}"...'.format(onlyfiles))
merge_file_out = self.le_name2.text()
if (merge_file_out.endswith(".pcap") or merge_file_out.endswith(".pcapng")) == False:
merge_file_out = merge_file_out + ".pcap"
self.pt_log2.appendPlainText("Сохранить в:")
self.pt_log2.appendPlainText(" " + merge_file_out)
self.pt_log2.appendPlainText("")
merge.mergecap(onlyfiles, merge_file_out)
class DataHubUi(QWidget):
def __init__(self, data_center: UniversalDataCenter):
super(DataHubUi, self).__init__()
self.__data_center = data_center
self.__translate = QtCore.QCoreApplication.translate
self.__combo_uri = QComboBox()
self.__line_identity = QLineEdit()
self.__table_main = EasyQTableWidget()
self.__datetime_since = QDateTimeEdit()
self.__datetime_until = QDateTimeEdit()
self.__button_query = QPushButton(self.__translate('', 'Query'))
self.__check_identity_enable = QCheckBox(
self.__translate('', 'Identity'))
self.__check_datetime_enable = QCheckBox(
self.__translate('', 'Datetime'))
self.init_ui()
# ---------------------------------------------------- UI Init -----------------------------------------------------
def init_ui(self):
self.__layout_control()
self.__config_control()
def __layout_control(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
line = QHBoxLayout()
line.addWidget(QLabel(self.__translate('', 'URI')), 0)
line.addWidget(self.__combo_uri, 10)
main_layout.addLayout(line)
line = QHBoxLayout()
line.addWidget(self.__check_identity_enable, 0)
line.addWidget(self.__line_identity, 10)
main_layout.addLayout(line)
line = QHBoxLayout()
line.addWidget(self.__check_datetime_enable, 0)
line.addWidget(self.__datetime_since, 10)
line.addWidget(self.__datetime_until, 10)
main_layout.addLayout(line)
line = QHBoxLayout()
line.addWidget(QLabel(' '), 10)
line.addWidget(self.__button_query, 1)
main_layout.addLayout(line)
main_layout.addWidget(self.__table_main)
def __config_control(self):
# self.__combo_uri.setEditable(True)
self.__check_identity_enable.setChecked(True)
self.__check_datetime_enable.setChecked(True)
self.__datetime_since.setDateTime(default_since())
self.__datetime_until.setDateTime(now())
self.__button_query.clicked.connect(self.on_button_query)
all_uri = self.__data_center.get_all_uri()
for uri in all_uri:
self.__combo_uri.addItem(uri)
def on_button_query(self):
uri = self.__combo_uri.currentText()
identity = self.__line_identity.text(
) if self.__check_identity_enable.isChecked() else None
since = self.__datetime_since.dateTime().toPyDateTime(
) if self.__check_datetime_enable.isChecked() else None
until = self.__datetime_until.dateTime().toPyDateTime(
) if self.__check_datetime_enable.isChecked() else None
result = self.__data_center.query(
uri, identity,
(since, until)) if self.__data_center is not None else None
if result is not None and '_id' in result.columns:
del result['_id']
write_df_to_qtable(result, self.__table_main)
class GeneralTab(TabWidget):
def __init__(self, font, parent=None):
super().__init__(parent, name="General")
mainLayout = QGridLayout(self)
familyNameLabel = QLabel("Family name:", self)
styleNameLabel = QLabel("Style name:", self)
designerLabel = QLabel("Designer:", self)
designerURLLabel = QLabel("Designer URL:", self)
manufacturerLabel = QLabel("Manufacturer:", self)
manufacturerURLLabel = QLabel("Manufacturer URL:", self)
copyrightLabel = QLabel("Copyright:", self)
licenseLabel = QLabel("License:", self)
licenseURLLabel = QLabel("License URL:", self)
trademarkLabel = QLabel("Trademark:", self)
# TODO: give visual feedback of input data validity using QLineEdit
# lose focus event
# http://snorf.net/blog/2014/08/09/using-qvalidator-in-pyqt4-to-validate-user-input/ # noqa
versionLabel = QLabel("Version:", self)
versionDotLabel = QLabel(".", self)
self.loadString(font, "familyName", "familyName")
self.loadString(font, "styleName", "styleName")
self.loadString(font, "openTypeNameDesigner", "designer")
self.loadString(font, "openTypeNameDesignerURL", "designerURL")
self.loadString(font, "openTypeNameManufacturer", "manufacturer")
self.loadString(font, "openTypeNameManufacturerURL", "manufacturerURL")
self.loadMultilineString(font, "copyright", "copyright")
self.loadMultilineString(font, "openTypeNameLicense", "license")
self.loadString(font, "openTypeNameLicenseURL", "licenseURL")
self.loadString(font, "trademark", "trademark")
self.loadInteger(font, "versionMajor", "versionMajor")
self.versionMajorEdit.setAlignment(Qt.AlignRight)
self.loadPositiveInteger(font, "versionMinor", "versionMinor")
mainLayout.addWidget(familyNameLabel, 0, 0)
mainLayout.addWidget(self.familyNameEdit, 0, 1, 1, 3)
mainLayout.addWidget(styleNameLabel, 0, 4)
mainLayout.addWidget(self.styleNameEdit, 0, 5)
mainLayout.addWidget(designerLabel, 1, 0)
mainLayout.addWidget(self.designerEdit, 1, 1, 1, 5)
mainLayout.addWidget(designerURLLabel, 2, 0)
mainLayout.addWidget(self.designerURLEdit, 2, 1, 1, 5)
mainLayout.addWidget(manufacturerLabel, 3, 0)
mainLayout.addWidget(self.manufacturerEdit, 3, 1, 1, 5)
mainLayout.addWidget(manufacturerURLLabel, 4, 0)
mainLayout.addWidget(self.manufacturerURLEdit, 4, 1, 1, 5)
mainLayout.addWidget(copyrightLabel, 5, 0)
mainLayout.addWidget(self.copyrightEdit, 5, 1, 1, 5)
mainLayout.addWidget(versionLabel, 6, 0)
mainLayout.addWidget(self.versionMajorEdit, 6, 1)
mainLayout.addWidget(versionDotLabel, 6, 2)
mainLayout.addWidget(self.versionMinorEdit, 6, 3)
dateCreatedLabel = QLabel("Date created:", self)
dateTime = QDateTime()
# dateTime.fromString(font.info.openTypeHeadCreated, "yyyy/MM/dd
# hh:mm:ss") # XXX: why does this not work?
dateCreated = font.info.openTypeHeadCreated
if dateCreated:
parse = dateCreated.split(" ")
if len(parse) == 2:
date = parse[0].split("/")
date = QDate(*(int(val) for val in date))
dateTime.setDate(date)
time = parse[1].split(":")
time = QTime(*(int(val) for val in time))
dateTime.setTime(time)
else:
cur = QDateTime.currentDateTime()
dateTime.setDate(cur.date())
dateTime.setTime(cur.time())
self.dateCreatedEdit = QDateTimeEdit(dateTime, self)
mainLayout.addWidget(dateCreatedLabel, 6, 4)
mainLayout.addWidget(self.dateCreatedEdit, 6, 5)
mainLayout.addWidget(licenseLabel, 7, 0)
mainLayout.addWidget(self.licenseEdit, 7, 1, 1, 5)
mainLayout.addWidget(licenseURLLabel, 8, 0)
mainLayout.addWidget(self.licenseURLEdit, 8, 1, 1, 5)
mainLayout.addWidget(trademarkLabel, 9, 0)
mainLayout.addWidget(self.trademarkEdit, 9, 1, 1, 5)
self.setLayout(mainLayout)
def writeValues(self, font):
self.writeString(font, "familyName", "familyName")
self.writeString(font, "styleName", "styleName")
self.writeString(font, "trademark", "trademark")
self.writeMultilineString(font, "copyright", "copyright")
self.writeString(font, "designer", "openTypeNameDesigner")
self.writeString(font, "designerURL", "openTypeNameDesignerURL")
self.writeString(font, "manufacturer", "openTypeNameManufacturer")
self.writeString(
font, "manufacturerURL", "openTypeNameManufacturerURL")
self.writeMultilineString(font, "license", "openTypeNameLicense")
self.writeString(font, "licenseURL", "openTypeNameLicenseURL")
self.writeInteger(font, "versionMajor", "versionMajor")
self.writePositiveInteger(font, "versionMinor", "versionMinor")
font.info.openTypeHeadCreated = \
self.dateCreatedEdit.dateTime().toString("yyyy/MM/dd hh:mm:ss")
class AnnouncementDownloaderUi(QWidget):
def __init__(self, sas_if: sasIF, task_manager):
super(AnnouncementDownloaderUi, self).__init__()
# ---------------- ext var ----------------
self.__sas_if = sas_if
# self.__data_center = self.__data_hub.get_data_center() if self.__data_hub is not None else None
# self.__data_utility = self.__data_hub.get_data_utility() if self.__data_hub is not None else None
self.__task_manager = task_manager
self.__translate = QtCore.QCoreApplication.translate
# Timer for update stock list
self.__timer = QTimer()
self.__timer.setInterval(1000)
self.__timer.timeout.connect(self.on_timer)
self.__timer.start()
# Ui component
self.__combo_name = SecuritiesSelector(self.__sas_if, self)
self.__radio_annual_report = QRadioButton('年报')
self.__radio_customize_filter = QRadioButton('自定义')
self.__line_filter_include = QLineEdit()
self.__line_filter_exclude = QLineEdit()
self.__button_download = QPushButton('确定')
self.__datetime_since = QDateTimeEdit(
QDateTime.currentDateTime().addYears(-3))
self.__datetime_until = QDateTimeEdit(QDateTime.currentDateTime())
self.init_ui()
# ---------------------------------------------------- UI Init -----------------------------------------------------
def init_ui(self):
self.__layout_control()
self.__config_control()
def __layout_control(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
main_layout.addLayout(
horizon_layout([QLabel('股票代码'), self.__combo_name], [1, 10]))
main_layout.addLayout(
horizon_layout([QLabel('报告起始'), self.__datetime_since], [1, 10]))
main_layout.addLayout(
horizon_layout([QLabel('报告截止'), self.__datetime_until], [1, 10]))
main_layout.addLayout(
horizon_layout([
QLabel('报告类型'), self.__radio_annual_report,
self.__radio_customize_filter
], [1, 5, 5]))
main_layout.addLayout(
horizon_layout([QLabel('包含词条(以,分隔)'), self.__line_filter_include],
[1, 10]))
main_layout.addLayout(
horizon_layout([QLabel('排除词条(以,分隔)'), self.__line_filter_exclude],
[1, 10]))
main_layout.addWidget(QLabel(DEFAULT_INFO))
main_layout.addWidget(self.__button_download)
def __config_control(self):
# self.__combo_name.setEditable(True)
# self.__combo_name.addItem('所有')
# self.__combo_name.addItem('股票列表载入中')
self.__radio_annual_report.setChecked(True)
self.__line_filter_include.setEnabled(False)
self.__line_filter_exclude.setEnabled(False)
self.__radio_customize_filter.setEnabled(False)
self.__radio_annual_report.clicked.connect(self.on_radio_report_type)
self.__radio_customize_filter.clicked.connect(
self.on_radio_report_type)
self.__button_download.clicked.connect(self.on_button_download)
def on_timer(self):
if self.__combo_name.count() > 1:
self.__combo_name.insertItem(0, ALL_STOCK_TEXT)
self.__combo_name.setCurrentIndex(0)
self.__timer.stop()
# # Check stock list ready and update combobox
# if self.__data_utility is not None:
# if self.__data_utility.stock_cache_ready():
# self.__combo_name.clear()
# self.__combo_name.addItem(ALL_STOCK_TEXT)
# stock_list = self.__data_utility.get_stock_list()
# for stock_identity, stock_name in stock_list:
# self.__combo_name.addItem(stock_identity + ' | ' + stock_name, stock_identity)
def on_radio_report_type(self):
if self.__radio_annual_report.isChecked():
self.__line_filter_include.setEnabled(False)
self.__line_filter_exclude.setEnabled(False)
else:
self.__line_filter_include.setEnabled(True)
self.__line_filter_exclude.setEnabled(True)
def on_button_download(self):
# input_securities = self.__combo_name.currentText()
# if '|' in input_securities:
# input_securities = input_securities.split('|')[0].strip()
input_securities = self.__combo_name.get_input_securities()
if input_securities == ALL_STOCK_TEXT:
if self.__sas_if is None:
QMessageBox.information(
self, QtCore.QCoreApplication.translate('main', '提示'),
QtCore.QCoreApplication.translate('main', '无法获取股票列表'),
QMessageBox.Yes, QMessageBox.No)
return
reply = QMessageBox.question(
self, QtCore.QCoreApplication.translate('main', '操作确认'),
QtCore.QCoreApplication.translate('main', DOWNLOAD_ALL_TIPS),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply != QMessageBox.Yes:
return
self.__build_download_task(input_securities)
def __build_download_task(self, securities: str):
task = AnnouncementDownloadTask()
task.securities = securities
task.period_since = self.__datetime_since.dateTime().toPyDateTime()
task.period_until = self.__datetime_until.dateTime().toPyDateTime()
task.filter_include = self.__line_filter_include.text().split(',')
task.filter_exclude = self.__line_filter_exclude.text().split(',')
task.report_type = \
AnnouncementDownloadTask.REPORT_TYPE_ANNUAL \
if self.__radio_annual_report.isChecked() else \
AnnouncementDownloadTask.REPORT_TYPE_NONE
task.task_manager = self.__task_manager
task.sas_if = self.__sas_if
# task.data_utility = self.__data_utility
if self.__task_manager is not None:
self.__task_manager.append_task(task)
else:
task.run()
class GeneralTab(QWidget):
name = "General"
def __init__(self, font, parent=None):
super(GeneralTab, self).__init__(parent)
mainLayout = QGridLayout(self)
familyNameLabel = QLabel("Family name:", self)
self.familyNameEdit = QLineEdit(font.info.familyName, self)
styleNameLabel = QLabel("Style name:", self)
self.styleNameEdit = QLineEdit(font.info.styleName, self)
mainLayout.addWidget(familyNameLabel, 0, 0)
mainLayout.addWidget(self.familyNameEdit, 0, 1, 1, 3)
mainLayout.addWidget(styleNameLabel, 0, 4)
mainLayout.addWidget(self.styleNameEdit, 0, 5)
designerLabel = QLabel("Designer:", self)
self.designerEdit = QLineEdit(font.info.openTypeNameDesigner, self)
mainLayout.addWidget(designerLabel, 1, 0)
mainLayout.addWidget(self.designerEdit, 1, 1, 1, 5)
designerURLLabel = QLabel("Designer URL:", self)
self.designerURLEdit = QLineEdit(
font.info.openTypeNameDesignerURL, self)
mainLayout.addWidget(designerURLLabel, 2, 0)
mainLayout.addWidget(self.designerURLEdit, 2, 1, 1, 5)
manufacturerLabel = QLabel("Manufacturer:", self)
self.manufacturerEdit = QLineEdit(
font.info.openTypeNameManufacturer, self)
mainLayout.addWidget(manufacturerLabel, 3, 0)
mainLayout.addWidget(self.manufacturerEdit, 3, 1, 1, 5)
manufacturerURLLabel = QLabel("Manufacturer URL:", self)
self.manufacturerURLEdit = QLineEdit(
font.info.openTypeNameManufacturerURL, self)
mainLayout.addWidget(manufacturerURLLabel, 4, 0)
mainLayout.addWidget(self.manufacturerURLEdit, 4, 1, 1, 5)
copyrightLabel = QLabel("Copyright:", self)
self.copyrightEdit = QLineEdit(font.info.copyright, self)
mainLayout.addWidget(copyrightLabel, 5, 0)
mainLayout.addWidget(self.copyrightEdit, 5, 1, 1, 5)
# TODO: give visual feedback of input data validity using QLineEdit
# lose focus event
# http://snorf.net/blog/2014/08/09/using-qvalidator-in-pyqt4-to-validate-user-input/ # noqa
versionLabel = QLabel("Version:", self)
if font.info.versionMajor is not None:
versionMajor = str(font.info.versionMajor)
else:
versionMajor = ''
self.versionMajorEdit = QLineEdit(versionMajor, self)
self.versionMajorEdit.setAlignment(Qt.AlignRight)
self.versionMajorEdit.setValidator(QIntValidator(self))
versionDotLabel = QLabel(".", self)
if font.info.versionMinor is not None:
versionMinor = str(font.info.versionMinor)
else:
versionMinor = ''
self.versionMinorEdit = QLineEdit(versionMinor, self)
validator = QIntValidator(self)
validator.setBottom(0)
self.versionMinorEdit.setValidator(validator)
mainLayout.addWidget(versionLabel, 6, 0)
mainLayout.addWidget(self.versionMajorEdit, 6, 1)
mainLayout.addWidget(versionDotLabel, 6, 2)
mainLayout.addWidget(self.versionMinorEdit, 6, 3)
dateCreatedLabel = QLabel("Date created:", self)
dateTime = QDateTime()
# dateTime.fromString(font.info.openTypeHeadCreated, "yyyy/MM/dd
# hh:mm:ss") # XXX: why does this not work?
dateCreated = font.info.openTypeHeadCreated
if dateCreated:
parse = dateCreated.split(" ")
if len(parse) == 2:
date = parse[0].split("/")
date = QDate(*(int(val) for val in date))
dateTime.setDate(date)
time = parse[1].split(":")
time = QTime(*(int(val) for val in time))
dateTime.setTime(time)
else:
cur = QDateTime.currentDateTime()
dateTime.setDate(cur.date())
dateTime.setTime(cur.time())
self.dateCreatedEdit = QDateTimeEdit(dateTime, self)
mainLayout.addWidget(dateCreatedLabel, 6, 4)
mainLayout.addWidget(self.dateCreatedEdit, 6, 5)
licenseLabel = QLabel("License:", self)
self.licenseEdit = QLineEdit(font.info.openTypeNameLicense, self)
mainLayout.addWidget(licenseLabel, 7, 0)
mainLayout.addWidget(self.licenseEdit, 7, 1, 1, 5)
licenseURLLabel = QLabel("License URL:", self)
self.licenseURLEdit = QLineEdit(font.info.openTypeNameLicenseURL, self)
mainLayout.addWidget(licenseURLLabel, 8, 0)
mainLayout.addWidget(self.licenseURLEdit, 8, 1, 1, 5)
trademarkLabel = QLabel("Trademark:", self)
self.trademarkEdit = QLineEdit(font.info.trademark, self)
mainLayout.addWidget(trademarkLabel, 9, 0)
mainLayout.addWidget(self.trademarkEdit, 9, 1, 1, 5)
self.setLayout(mainLayout)
def writeValues(self, font):
familyName = self.familyNameEdit.text()
if familyName != '':
font.info.familyName = familyName
else:
font.info.trademark = None
styleName = self.styleNameEdit.text()
if styleName != '':
font.info.styleName = styleName
else:
font.info.trademark = None
designer = self.designerEdit.text()
if designer != '':
font.info.openTypeNameDesigner = designer
else:
font.info.trademark = None
designerURL = self.designerURLEdit.text()
if designerURL != '':
font.info.openTypeNameDesignerURL = designerURL
else:
font.info.trademark = None
manufacturer = self.manufacturerEdit.text()
if manufacturer != '':
font.info.openTypeNameManufacturer = manufacturer
else:
font.info.trademark = None
manufacturerURL = self.manufacturerURLEdit.text()
if manufacturerURL != '':
font.info.openTypeNameManufacturerURL = manufacturerURL
else:
font.info.trademark = None
copyright = self.copyrightEdit.text()
if copyright != '':
font.info.copyright = copyright
else:
font.info.trademark = None
versionMajor = self.versionMajorEdit.text()
if versionMajor:
font.info.versionMajor = int(versionMajor)
else:
font.info.versionMajor = None
versionMinor = self.versionMinorEdit.text()
if versionMinor:
font.info.versionMinor = int(versionMinor)
else:
font.info.versionMinor = None
font.info.openTypeHeadCreated = self.dateCreatedEdit.dateTime(
).toString("yyyy/MM/dd hh:mm:ss")
license = self.licenseEdit.text()
if license != '':
font.info.openTypeNameLicense = license
else:
font.info.trademark = None
licenseURL = self.licenseURLEdit.text()
if licenseURL != '':
font.info.openTypeNameLicenseURL = licenseURL
else:
font.info.trademark = None
trademark = self.trademarkEdit.text()
if trademark != '':
font.info.trademark = trademark
else:
font.info.trademark = None
class StockMemoEditor(QDialog):
def __init__(self, history: History):
super(StockMemoEditor, self).__init__()
self.__history = history
self.__source = ''
self.__current_record = None
self.__label_uuid = QLabel()
self.__label_source = QLabel()
self.__text_record = QTextEdit()
self.__datetime_time = QDateTimeEdit(QDateTime.currentDateTime())
self.__button_apply = QPushButton('保存')
self.__button_cancel = QPushButton('取消')
self.init_ui()
self.config_ui()
def init_ui(self):
root_layout = QVBoxLayout()
self.setLayout(root_layout)
group_box, group_layout = create_v_group_box('')
group_layout.addWidget(self.__label_uuid)
group_layout.addWidget(self.__label_source)
group_layout.addWidget(self.__datetime_time)
# group_layout.addLayout(horizon_layout([QLabel('笔记ID'), self.__label_uuid]))
# group_layout.addLayout(horizon_layout([QLabel('笔记文件'), self.__label_source]))
# group_layout.addLayout(horizon_layout([QLabel('记录时间'), self.__datetime_time]))
root_layout.addWidget(group_box, 0)
root_layout.addWidget(self.__text_record, 10)
root_layout.addLayout(horizon_layout([self.__button_apply, self.__button_cancel]))
self.setMinimumSize(500, 600)
def config_ui(self):
self.__label_uuid.setEnabled(False)
self.__label_source.setEnabled(False)
self.setWindowTitle('笔记')
self.__datetime_time.setCalendarPopup(True)
self.__button_apply.clicked.connect(self.on_button_apply)
self.__button_cancel.clicked.connect(self.on_button_cancel)
def on_button_apply(self):
if self.__current_record is None:
self.__current_record = HistoricalRecord()
else:
self.__current_record.reset()
if not self.ui_to_record(self.__current_record):
QMessageBox.information(self,
QtCore.QCoreApplication.translate('History', '错误'),
QtCore.QCoreApplication.translate('History', '采集界面数据错误'),
QMessageBox.Ok, QMessageBox.Ok)
return
if self.__source is None or self.__source == '':
QMessageBox.information(self,
QtCore.QCoreApplication.translate('History', '错误'),
QtCore.QCoreApplication.translate('History', '没有指定数据源，无法保存'),
QMessageBox.Ok, QMessageBox.Ok)
return
self.__current_record.set_source(self.__source)
self.__history.update_records([self.__current_record])
records = self.__history.get_record_by_source(self.__source)
result = HistoricalRecordLoader.to_local_source(records, self.__source)
if not result:
QMessageBox.information(self,
QtCore.QCoreApplication.translate('History', '错误'),
QtCore.QCoreApplication.translate('History', '保存到数据源 [%s] 失败' % self.__source),
QMessageBox.Ok, QMessageBox.Ok)
return
self.close()
def on_button_cancel(self):
self.close()
# ---------------------------------------------------------------------------
def set_memo(self, memo: HistoricalRecord):
self.__current_record = memo
self.__source = memo.source()
self.record_to_ui(memo)
def set_source(self, source: str):
self.__source = source
def set_memo_datetime(self, date_time: datetime.datetime):
self.__datetime_time.setDateTime(date_time)
# -------------------------------- Operation --------------------------------
def clear_ui(self):
self.__label_uuid.setText('')
self.__label_source.setText('')
self.__text_record.clear()
def ui_to_record(self, record: HistoricalRecord) -> bool:
input_time = self.__datetime_time.dateTime()
input_memo = self.__text_record.toPlainText()
date_time = input_time.toPyDateTime()
record.set_label_tags('time', date_time.strftime('%Y-%m-%d %H:%M:%S'))
record.set_label_tags('event', input_memo)
record.set_focus_label('time')
return True
def record_to_ui(self, record: HistoricalRecord or str):
self.clear_ui()
self.__label_uuid.setText(LabelTagParser.tags_to_text(record.uuid()))
self.__label_source.setText(self.__source)
self.__text_record.setText(LabelTagParser.tags_to_text(record.event()))
since = record.since()
pytime = HistoryTime.tick_to_pytime(since)
self.__datetime_time.setDateTime(pytime)
class GeneralTab(TabWidget):
def __init__(self, font, parent=None):
super().__init__(parent)
self.name = self.tr("General")
mainLayout = QGridLayout(self)
familyNameLabel = RLabel(self.tr("Family name:"), self)
styleNameLabel = RLabel(self.tr("Style name:"), self)
designerLabel = RLabel(self.tr("Designer:"), self)
designerURLLabel = RLabel(self.tr("Designer URL:"), self)
manufacturerLabel = RLabel(self.tr("Manufacturer:"), self)
manufacturerURLLabel = RLabel(self.tr("Manufacturer URL:"), self)
copyrightLabel = RLabel(self.tr("Copyright:"), self)
licenseLabel = RLabel(self.tr("License:"), self)
licenseURLLabel = RLabel(self.tr("License URL:"), self)
trademarkLabel = RLabel(self.tr("Trademark:"), self)
versionLabel = RLabel(self.tr("Version:"), self)
versionDotLabel = QLabel(".", self)
versionDotLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
# TODO: give visual feedback of input data validity using QLineEdit
# lose focus event
# http://snorf.net/blog/2014/08/09/using-qvalidator-in-pyqt4-to-validate-user-input/ # noqa
self.loadString(font, "familyName", "familyName")
self.loadString(font, "styleName", "styleName")
self.loadString(font, "openTypeNameDesigner", "designer")
self.loadString(font, "openTypeNameDesignerURL", "designerURL")
self.loadString(font, "openTypeNameManufacturer", "manufacturer")
self.loadString(font, "openTypeNameManufacturerURL", "manufacturerURL")
self.loadMultilineString(font, "copyright", "copyright")
self.loadMultilineString(font, "openTypeNameLicense", "license")
self.loadString(font, "openTypeNameLicenseURL", "licenseURL")
self.loadString(font, "trademark", "trademark")
self.loadInteger(font, "versionMajor", "versionMajor")
self.versionMajorEdit.setAlignment(Qt.AlignRight)
self.loadPositiveInteger(font, "versionMinor", "versionMinor")
mainLayout.addWidget(familyNameLabel, 0, 0)
mainLayout.addWidget(self.familyNameEdit, 0, 1, 1, 3)
mainLayout.addWidget(styleNameLabel, 0, 4)
mainLayout.addWidget(self.styleNameEdit, 0, 5)
mainLayout.addWidget(designerLabel, 1, 0)
mainLayout.addWidget(self.designerEdit, 1, 1, 1, 5)
mainLayout.addWidget(designerURLLabel, 2, 0)
mainLayout.addWidget(self.designerURLEdit, 2, 1, 1, 5)
mainLayout.addWidget(manufacturerLabel, 3, 0)
mainLayout.addWidget(self.manufacturerEdit, 3, 1, 1, 5)
mainLayout.addWidget(manufacturerURLLabel, 4, 0)
mainLayout.addWidget(self.manufacturerURLEdit, 4, 1, 1, 5)
mainLayout.addWidget(copyrightLabel, 5, 0)
mainLayout.addWidget(self.copyrightEdit, 5, 1, 1, 5)
mainLayout.addWidget(versionLabel, 6, 0)
mainLayout.addWidget(self.versionMajorEdit, 6, 1)
mainLayout.addWidget(versionDotLabel, 6, 2)
mainLayout.addWidget(self.versionMinorEdit, 6, 3)
dateCreatedLabel = RLabel(self.tr("Date created:"), self)
dateTime = QDateTime()
# dateTime.fromString(font.info.openTypeHeadCreated, "yyyy/MM/dd
# hh:mm:ss") # XXX: why does this not work?
dateCreated = font.info.openTypeHeadCreated
if dateCreated:
parse = dateCreated.split(" ")
if len(parse) == 2:
date = parse[0].split("/")
date = QDate(*(int(val) for val in date))
dateTime.setDate(date)
time = parse[1].split(":")
time = QTime(*(int(val) for val in time))
dateTime.setTime(time)
else:
cur = QDateTime.currentDateTime()
dateTime.setDate(cur.date())
dateTime.setTime(cur.time())
self.dateCreatedEdit = QDateTimeEdit(dateTime, self)
mainLayout.addWidget(dateCreatedLabel, 6, 4)
mainLayout.addWidget(self.dateCreatedEdit, 6, 5)
mainLayout.addWidget(licenseLabel, 7, 0)
mainLayout.addWidget(self.licenseEdit, 7, 1, 1, 5)
mainLayout.addWidget(licenseURLLabel, 8, 0)
mainLayout.addWidget(self.licenseURLEdit, 8, 1, 1, 5)
mainLayout.addWidget(trademarkLabel, 9, 0)
mainLayout.addWidget(self.trademarkEdit, 9, 1, 1, 5)
self.setLayout(mainLayout)
def writeValues(self, font):
self.writeString(font, "familyName", "familyName")
self.writeString(font, "styleName", "styleName")
self.writeString(font, "trademark", "trademark")
self.writeMultilineString(font, "copyright", "copyright")
self.writeString(font, "designer", "openTypeNameDesigner")
self.writeString(font, "designerURL", "openTypeNameDesignerURL")
self.writeString(font, "manufacturer", "openTypeNameManufacturer")
self.writeString(font, "manufacturerURL",
"openTypeNameManufacturerURL")
self.writeMultilineString(font, "license", "openTypeNameLicense")
self.writeString(font, "licenseURL", "openTypeNameLicenseURL")
self.writeInteger(font, "versionMajor", "versionMajor")
self.writePositiveInteger(font, "versionMinor", "versionMinor")
font.info.openTypeHeadCreated = \
self.dateCreatedEdit.dateTime().toString("yyyy/MM/dd hh:mm:ss")
class MainWidget(QWidget):
'''
The MainWidget class is the home screen of the app and allows the user to input parameters for analysis.
Attributes:
output_path (str): the output path selected by the user
file (str): the file path selected by the user
ad_number (int): the integer selected by the user for the averaging duration
ad_unit (int): the unit of time selected by the user for the averaging duration
time_selected (bool): whether or not the user has selected a specific time range
VALID_FILES (list of str): the list of valid file types accepted
AD_UNITS (list of str): the list of time units selectable by the user
time_selectors (QWidget): a widget containing the time range inputs
layout (QVBoxLayout): a vertical layout for the screen
'''
def __init__(self):
super().__init__()
# initialize variables
self.output_path = None
self.file = None
self.ad_number = None
self.ad_unit = None
self.time_selected = False
# single definition point for hardcoded values (valid file types and averaging duration units)
self.VALID_FILES = ["xlsx", "xls", "csv"]
self.AD_UNITS = ["Minutes", "Hours", "Days", "Weeks", "Months", "Years"]
# create static UI elements
title_label = QLabel("CDC Air Quality Analysis")
title_label.setObjectName("title")
file_select_layout = self.file_select_layout()
output_path_layout = self.output_path_layout()
averaging_duration_layout = self.averaging_duration_layout()
time_range_layout = self.time_range_layout()
self.time_selectors = self.create_time_selectors()
# create process button and connect to function
process_file = QPushButton("Process File")
process_file.clicked.connect(self.begin_process)
# define the layout of the screen
self.layout = QVBoxLayout()
self.layout.addWidget(title_label)
self.layout.addLayout(file_select_layout)
self.layout.addLayout(output_path_layout)
self.layout.addLayout(averaging_duration_layout)
self.layout.addLayout(time_range_layout)
self.layout.addWidget(self.time_selectors)
self.layout.addWidget(process_file)
self.setLayout(self.layout)
# define UI elements and layout for the file select input
def file_select_layout(self):
instruction_label = QLabel("Select Data File:")
instruction_label.setObjectName("instruction")
self.file_name = QLabel("No File Selected")
self.file_name.setObjectName("fileName")
self.file_name.setFixedWidth(200)
button = QPushButton("Browse")
button.setFixedWidth(100)
button.clicked.connect(partial(self.get_file, self.file_name))
layout = QHBoxLayout()
layout.addWidget(instruction_label)
layout.addWidget(self.file_name)
layout.addWidget(button)
layout.setContentsMargins(6, 10, 6, 8)
return layout
# define UI elements and layout for the output path select input
def output_path_layout(self):
instruction_label = QLabel("Select Output Path:")
instruction_label.setObjectName("instruction")
self.output_select = QLabel("No Path Selected")
self.output_select.setObjectName("fileName")
self.output_select.setFixedWidth(200)
button = QPushButton("Browse")
button.setFixedWidth(100)
button.clicked.connect(partial(self.get_output, self.output_select))
layout = QHBoxLayout()
layout.addWidget(instruction_label)
layout.addWidget(self.output_select)
layout.addWidget(button)
layout.setContentsMargins(6, 10, 6, 8)
return layout
# define UI elements and layout for averaging duration input
def averaging_duration_layout(self):
instruction_label = QLabel("Select Averaging Duration:")
instruction_label.setObjectName("instruction")
self.ad_number_input = QLineEdit(self)
self.ad_number_input.setPlaceholderText("Input an Integer")
self.ad_number_input.setFixedWidth(125)
self.ad_number_input.setFixedHeight(25)
# define dropdown menu (known as a ComboBox)
self.ad_unit = self.AD_UNITS[0] # default
comboBox = QComboBox(self)
comboBox.setFixedWidth(100)
for item in self.AD_UNITS:
comboBox.addItem(item)
comboBox.currentIndexChanged.connect(partial(self.selection_change, comboBox))
layout = QHBoxLayout()
layout.addWidget(instruction_label)
layout.addWidget(self.ad_number_input)
layout.addWidget(comboBox)
layout.setContentsMargins(6, 8, 6, 8)
return layout
# called whenever the user makes a new selection from the averaging duration dropdown
def selection_change(self, cb):
self.ad_unit = cb.currentText()
# define UI elements and layout for the time range input
def time_range_layout(self):
instruction_label = QLabel("Use Time Range?")
instruction_label.setObjectName("instruction")
# time range is optional, so these radio buttons formalize that choice
yes_rb = QRadioButton("Yes")
no_rb = QRadioButton("No")
no_rb.setChecked(True)
yes_rb.toggled.connect(partial(self.rb_state, yes_rb))
no_rb.toggled.connect(partial(self.rb_state, no_rb))
layout = QHBoxLayout()
layout.addWidget(instruction_label)
layout.addWidget(yes_rb)
layout.addWidget(no_rb)
layout.setContentsMargins(6,8,6,8)
layout.insertSpacing(1, 85)
layout.insertSpacing(3, 80)
return layout
# define UI elements and layout for the time range selectors
def create_time_selectors(self):
instruction_label = QLabel("Start Time:")
instruction_label.setObjectName("instruction")
self.start = QDateTimeEdit(self)
self.start.setCalendarPopup(True)
self.start.setDateTime(QDateTime.currentDateTime())
instruction2_label = QLabel("End Time:")
instruction2_label.setObjectName("instruction")
self.end = QDateTimeEdit(self)
self.end.setCalendarPopup(True)
self.end.setDateTime(QDateTime.currentDateTime())
layout = QHBoxLayout()
layout.setContentsMargins(6, 8, 6, 10)
layout.addWidget(instruction_label)
layout.addWidget(self.start)
layout.addWidget(instruction2_label)
layout.addWidget(self.end)
# define a new widget so we can enable and disable it based on the radio button input
widget = QWidget()
widget.setLayout(layout)
widget.setFixedHeight(50)
widget.setEnabled(False)
return widget
# called when the user clicks the select file button
def get_file(self, label):
# get valid file types from array
valid_files = ""
for ext in self.VALID_FILES:
valid_files += "*." + ext + " "
# open file explorer dialog prefilled with valid file types
file_name, _ = QFileDialog.getOpenFileName(self, "Select Data Files", "",
"Data Files (" + valid_files.strip() +");;All Files (*)")
# if user closes dialog without selecting a file path, it will return None
if file_name:
self.file = file_name.split("/")[-1]
self.file_path = file_name
label.setText(self.file)
# called when the user clicks the select output path button
def get_output(self, label):
path = QFileDialog.getExistingDirectory(self, "Choose an Output Directory", options=QFileDialog.ShowDirsOnly)
if path:
self.output_path = path
split_path = path.split("/")
if len(split_path) >= 2:
label.setText(split_path[-2] + "/" + split_path[-1])
else:
label.setText(self.output_path)
# change the state of the radio buttons and toggle the time range widget
def rb_state(self, clicked):
if clicked.text() == "Yes" and clicked.isChecked() == True:
self.time_selectors.setEnabled(True)
self.time_selected = True
elif clicked.text() == "No" and clicked.isChecked() == True:
self.time_selectors.setEnabled(False)
self.time_selected = False
# perform input validation and begin processing
def begin_process(self):
main_window = self.parentWidget().parentWidget()
# check that a file has been selected
if not self.file:
main_window.raise_error("Input Error",
"No File Selected",
"Please select a file for analysis.")
return
extension = self.file.split(".")[-1]
# check that the file selected is a valid file type
if not extension in self.VALID_FILES:
main_window.raise_error("Input Error",
"Invalid File Type Selected",
"Valid file types include " + ", ".join(self.VALID_FILES) + ".")
return
# check that the user has inputted a number and unit for averaging duration
self.ad_number = self.ad_number_input.text()
if not self.ad_number or not self.ad_unit:
main_window.raise_error("Input Error",
"Invalid Averaging Duration Selected",
"Please input an integer and unit for the averaging duration.")
return
# check that the ad_num input is actually a number
try:
self.ad_number = int(self.ad_number)
except ValueError:
main_window.raise_error("Input Error",
"Invalid Averaging Duration Selected",
"Averaging duration must be a whole number.")
return
# check that the ad_num input is actually an integer
# we want the user to be made aware that it must be an integer
if not round(self.ad_number) == self.ad_number:
main_window.raise_error("Input Error",
"Invalid Averaging Duration Selected",
"Averaging duration must be a whole number.")
return
# if the user has chosen a time range, make sure that end time is not before start time
if self.time_selected:
start_time = self.start.dateTime()
end_time = self.end.dateTime()
if start_time > end_time:
main_window.raise_error("Input Error",
"Invalid Time Entered",
"End Time cannot be greater than Start Time.")
return
else:
start_time = None
end_time = None
# callback to main window to initiate process and change the screen
main_window.start_analysis(
self.file,
self.file_path,
self.output_path,
self.ad_number,
self.ad_unit,
start_time,
end_time
)
# reset and clear all inputs
def reset(self):
self.file = None
self.file_name.setText("No File Selected")
self.output_path = None
self.output_select.setText("No Path Selected")
self.ad_number = None
self.ad_number_input.clear()
self.start.setDateTime(QDateTime.currentDateTime())
self.end.setDateTime(QDateTime.currentDateTime())
class Reservations(QWidget):
"""
Klasa odpowiedzialna za widget klienci
"""
def __init__(self, parent, db):
super(QWidget, self).__init__(parent)
self.parent = parent
self.btn_mod = QPushButton('Zmiana statusu')
self.btn_usun = QPushButton('Usuń')
self.btn_dodaj = QPushButton('Dodaj')
self.lbl_klient_ = QLabel('')
self.lbl_usluga_ = QLabel('')
self.lbl_termin_ = QDateTimeEdit()
self.gb_layout = QVBoxLayout()
self.kalendarz = QCalendarWidget()
self.view_u = QTableView()
self.view_k = QTableView()
self.view_p = QTableView()
self.view = QTableView()
self.proxy_u = QSortFilterProxyModel(self)
self.proxy_k = QSortFilterProxyModel(self)
self.proxy_p = QSortFilterProxyModel(self)
self.proxy = QSortFilterProxyModel(self)
self.id_klient = -1
self.id_usluga = -1
self.id_pracownik = -1
self.id_rezerwacje = -1
self.data = None
self.data_do = None
self.dzien_tyg = 0
self.czas = []
# Lista składana przycisków godzin
self.btn_godz = [QPushButton(str(i + 1)) for i in range(16)]
# Parametry połączenia z bazą
self.model_u = QSqlTableModel(self, db)
self.model_k = QSqlTableModel(self, db)
self.model_p = QSqlTableModel(self, db)
self.model = QSqlTableModel(self, db)
self.initUI()
def initUI(self):
"""
Inicjuje UI
"""
self.view_u.setObjectName('Usługi')
self.view_k.setObjectName('Klienci')
self.view_p.setObjectName('Pracownicy')
self.view.setObjectName('Rezerwacje')
self.table_init_u()
self.table_init_k()
self.table_init_p()
self.table_init()
self.btn_mod.setDisabled(True)
self.btn_usun.setDisabled(True)
self.btn_dodaj.setDisabled(True)
# Tworzenie kontrolek
lbl_wysz_u = QLabel('Wyszukaj usługę:')
lbl_wysz_k = QLabel('Wyszukaj klienta:')
lbl_wysz_p = QLabel('Wyszukaj pracownika:')
txt_wysz_u = QLineEdit(self)
txt_wysz_k = QLineEdit(self)
txt_wysz_p = QLineEdit(self)
lbl_klient = QLabel('Klient:')
lbl_usluga = QLabel('Usługa:')
lbl_termin = QLabel('Termin:')
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.kalendarz.sizePolicy().hasHeightForWidth())
self.kalendarz.setSizePolicy(sizePolicy)
# Tworzenie widoków
centralbox = QHBoxLayout()
hbox_wysz_u = QHBoxLayout()
hbox_wysz_k = QHBoxLayout()
hbox_wysz_p = QHBoxLayout()
vbox_u = QVBoxLayout()
vbox_k = QVBoxLayout()
vbox_p = QVBoxLayout()
vbox_right = QVBoxLayout()
hbox_btn = QHBoxLayout()
hbox_k = QHBoxLayout()
hbox_u = QHBoxLayout()
hbox_t = QHBoxLayout()
vbox_cal = QVBoxLayout()
groupbox = QGroupBox('Godziny:')
groupbox.setLayout(self.gb_layout)
hbox_left = QHBoxLayout()
# Metody
self.lbl_termin_.setCalendarWidget(self.kalendarz)
self.lbl_termin_.setDate(self.kalendarz.selectedDate())
self.dzien_tyg = self.kalendarz.selectedDate().dayOfWeek()
txt_wysz_u.textChanged.connect(self.searching_u)
txt_wysz_k.textChanged.connect(self.searching_k)
txt_wysz_p.textChanged.connect(self.searching_p)
self.view_k.clicked.connect(lambda: self.clicked_table(self.view_k))
self.view_p.clicked.connect(lambda: self.clicked_table(self.view_p))
self.view_u.clicked.connect(lambda: self.clicked_table(self.view_u))
self.view.clicked.connect(lambda: self.clicked_table(self.view))
self.kalendarz.clicked.connect(self.show_data)
self.btn_dodaj.clicked.connect(self.add)
self.btn_mod.clicked.connect(self.modify)
self.btn_usun.clicked.connect(self.remove)
# Ustawianie widoków
hbox_wysz_k.addWidget(lbl_wysz_k)
hbox_wysz_k.addWidget(txt_wysz_k)
hbox_wysz_p.addWidget(lbl_wysz_p)
hbox_wysz_p.addWidget(txt_wysz_p)
hbox_wysz_u.addWidget(lbl_wysz_u)
hbox_wysz_u.addWidget(txt_wysz_u)
vbox_u.addLayout(hbox_wysz_u)
vbox_u.addWidget(self.view_u)
vbox_k.addLayout(hbox_wysz_k)
vbox_k.addWidget(self.view_k)
vbox_p.addLayout(hbox_wysz_p)
vbox_p.addWidget(self.view_p)
vbox_right.addLayout(vbox_p)
vbox_right.addLayout(vbox_u)
vbox_right.addLayout(vbox_k)
hbox_btn.addWidget(self.btn_usun)
hbox_btn.addWidget(self.btn_mod)
hbox_k.addWidget(lbl_klient)
hbox_k.addWidget(self.lbl_klient_)
hbox_u.addWidget(lbl_usluga)
hbox_u.addWidget(self.lbl_usluga_)
hbox_t.addWidget(lbl_termin)
hbox_t.addWidget(self.lbl_termin_)
vbox_cal.addWidget(self.kalendarz)
vbox_cal.addLayout(hbox_u)
vbox_cal.addLayout(hbox_t)
vbox_cal.addLayout(hbox_k)
self.view.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum))
vbox_cal.addWidget(self.view)
vbox_cal.addLayout(hbox_btn)
vbox_cal.addWidget(self.btn_dodaj)
hbox_left.addLayout(vbox_cal)
hbox_left.addWidget(groupbox)
centralbox.addLayout(hbox_left)
centralbox.addLayout(vbox_right)
self.setLayout(centralbox)
self.show()
def show_data(self):
self.lbl_termin_.setDate(self.kalendarz.selectedDate())
self.dzien_tyg = self.kalendarz.selectedDate().dayOfWeek()
self.clicked_table(self.view_p)
def table_init_u(self):
"""
Inicjuje wygląd tabeli usługi
"""
# self.model_u.setTable('uslugi')
query = QSqlQuery(
'SELECT uslugi.uslugi_id, uslugi.nazwa, uslugi.cena, date_format(uslugi.czas, "%H:%i") AS czas FROM uslugi NATURAL JOIN uzytkownik_usluga WHERE uzytkownik_usluga.uzytkownik_id = '
+ str(self.id_pracownik) + ';')
self.model_u.setQuery(query)
# self.model_u.select()
self.proxy_u.setSourceModel(self.model_u)
naglowki = {
'uslugi_id': 'ID',
'nazwa': 'Nazwa',
'cena': 'Cena',
"czas": 'Czas',
}
# Ustawianie nagłówków
ilosc_kolumn = self.model_u.columnCount()
for i in range(ilosc_kolumn):
nazwa_kolumn = self.model_u.headerData(i, Qt.Horizontal)
self.model_u.setHeaderData(i, Qt.Horizontal,
naglowki[nazwa_kolumn])
self.view_u.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.view_u.setSortingEnabled(True)
self.view_u.setAlternatingRowColors(True)
# Wczytanie danych
self.view_u.setModel(self.proxy_u)
self.view_u.hideColumn(0)
self.view_u.sortByColumn(1, Qt.AscendingOrder)
self.view_u.setEditTriggers(QAbstractItemView.NoEditTriggers)
def table_init_k(self):
"""
Inicjuje wygląd tabeli klienta
"""
self.model_k.setTable('klienci')
query = QSqlQuery(
'SELECT klienci_id, imie, nazwisko, email, telefon, ulica, numer_mieszkania, miejscowosc, poczta FROM '
'klienci;')
self.model_k.setQuery(query)
# self.model_k.select()
self.proxy_k.setSourceModel(self.model_k)
naglowki = {
'klienci_id': 'ID',
'imie': 'Imię',
'nazwisko': 'Nazwisko',
"email": 'Email',
'telefon': 'Telefon',
'ulica': 'Ulica',
'numer_mieszkania': 'Numer mieszkania',
'miejscowosc': 'Miejscowosc',
'poczta': 'Kod pocztowy',
}
# Ustawianie nagłówków
ilosc_kolumn = self.model_k.columnCount()
for i in range(ilosc_kolumn):
nazwa_kolumn = self.model_k.headerData(i, Qt.Horizontal)
self.model_k.setHeaderData(i, Qt.Horizontal,
naglowki[nazwa_kolumn])
self.view_k.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.view_k.setSortingEnabled(True)
self.view_k.setAlternatingRowColors(True)
# Wczytanie danych
self.view_k.setModel(self.proxy_k)
self.view_k.hideColumn(0)
self.view_k.sortByColumn(1, Qt.AscendingOrder)
self.view_k.setEditTriggers(QAbstractItemView.NoEditTriggers)
def table_init_p(self):
"""
Inicjuje wygląd tabeli pracownik
"""
self.model_p.setTable('uzytkownik')
query = QSqlQuery(
'SELECT uzytkownik_id, imie, nazwisko FROM uzytkownik WHERE '
'pracownik = 1;')
self.model_p.setQuery(query)
# self.model_p.select()
self.proxy_p.setSourceModel(self.model_p)
naglowki = {
'uzytkownik_id': 'ID',
'imie': 'Imię',
"nazwisko": 'Nazwisko',
}
# Ustawianie nagłówków
ilosc_kolumn = self.model_p.columnCount()
for i in range(ilosc_kolumn):
nazwa_kolumn = self.model_p.headerData(i, Qt.Horizontal)
self.model_p.setHeaderData(i, Qt.Horizontal,
naglowki[nazwa_kolumn])
self.view_p.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.view_p.setSortingEnabled(True)
self.view_p.setAlternatingRowColors(True)
# Wczytanie danych
self.view_p.setModel(self.proxy_p)
self.view_p.hideColumn(0)
self.view_p.sortByColumn(1, Qt.AscendingOrder)
self.view_p.setEditTriggers(QAbstractItemView.NoEditTriggers)
def table_init(self):
"""
Inicjuje wygląd tabeli
"""
query = QSqlQuery(
'SELECT wizyty.wizyty_id, CONCAT(klienci.imie, " ", klienci.nazwisko) AS klient, uslugi.nazwa, '
'wizyty.rezerwacja_od, wizyty.rezerwacja_do, wizyty.status FROM klienci, uslugi NATURAL JOIN wizyty WHERE wizyty.rezerwacja_od > CURRENT_TIMESTAMP AND wizyty.uzytkownik_id = '
+ str(self.id_pracownik) + ';')
self.model.setQuery(query)
self.proxy.setSourceModel(self.model)
naglowki = {
'wizyty_id': 'ID',
'klient': 'Klient',
'nazwa': 'Usługa',
'rezerwacja_od': 'Rezerwacja od',
"rezerwacja_do": 'Rezerwacja do',
'status': 'Status rezerwacji'
}
# Ustawianie nagłówków
ilosc_kolumn = self.model.columnCount()
for i in range(ilosc_kolumn):
nazwa_kolumn = self.model.headerData(i, Qt.Horizontal)
self.model.setHeaderData(i, Qt.Horizontal, naglowki[nazwa_kolumn])
self.view.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.view.setSortingEnabled(True)
self.view.setAlternatingRowColors(True)
# Wczytanie danych
self.view.setModel(self.proxy)
self.view.hideColumn(0)
self.view.sortByColumn(4, Qt.AscendingOrder)
self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
def clicked_table(self, view):
"""
Metoda edytująca zaznaczone wiersze - Wstawia wartości z wierszy w odpowiednie pola
"""
index = (view.selectionModel().currentIndex())
if view.objectName() == 'Klienci':
self.id_klient = index.sibling(index.row(), 0).data()
self.lbl_klient_.setText('<b>' +
index.sibling(index.row(), 1).data() +
' ' +
index.sibling(index.row(), 2).data() +
'</b>')
elif view.objectName() == 'Usługi':
self.id_usluga = index.sibling(index.row(), 0).data()
self.lbl_usluga_.setText('<b>' +
index.sibling(index.row(), 1).data() +
'</b>')
self.data_do = index.sibling(index.row(), 3).data()
elif view.objectName() == 'Rezerwacje':
self.id_rezerwacje = index.sibling(index.row(), 0).data()
if self.id_rezerwacje > 0:
self.btn_mod.setEnabled(True)
self.btn_usun.setEnabled(True)
elif view.objectName() == 'Pracownicy':
self.id_pracownik = index.sibling(index.row(), 0).data()
self.czas = []
for i in reversed(range(self.gb_layout.count())):
self.gb_layout.itemAt(i).widget().setParent(None)
czas = datetime.datetime(2000, 1, 1, 8, 0)
dzien = {
1: ('pon_od', 'pon_do'),
2: ('wt_od', 'wt_do'),
3: ('sr_od', 'sr_do'),
4: ('czw_od', 'czw_do'),
5: ('pt_od', 'pt_do'),
6: ('sob_od', 'sob_do'),
7: ('', '')
}
query = 'SELECT date_format({}, "%H") AS g_start, date_format({}, "%H") AS g_stop FROM godziny WHERE ' \
'uzytkownik_id = {};'.format(dzien[self.dzien_tyg][0], dzien[self.dzien_tyg][1], self.id_pracownik)
wynik = query_to_db(query)
if wynik:
godzina_stop = (int(wynik[1]) - int(wynik[0])) * 2
godzina = int(wynik[0])
for btn in self.btn_godz:
btn.setEnabled(True)
else:
godzina_stop = 0
godzina = 1
for btn in self.btn_godz:
btn.setDisabled(True)
minuta = 0
czas = datetime.time(godzina, minuta)
for i in range(godzina_stop):
self.btn_godz[i].setText(czas.strftime("%H:%M"))
self.czas.append(czas)
self.btn_godz[i].setObjectName(str(i))
self.gb_layout.addWidget(self.btn_godz[i])
if i % 2 != 0:
godzina += 1
minuta = 0
else:
minuta = 30
czas = datetime.time(godzina, minuta)
QMetaObject.connectSlotsByName(self)
# Czyszczenie, odświeżanie
self.refresh()
query = QSqlQuery(
'SELECT uslugi.uslugi_id, uslugi.nazwa, uslugi.cena, date_format(uslugi.czas, "%H:%i") AS czas FROM uslugi NATURAL JOIN uzytkownik_usluga WHERE uzytkownik_usluga.uzytkownik_id = '
+ str(self.id_pracownik) + ';')
self.model_u.setQuery(query)
self.lbl_klient_.setText('')
self.lbl_usluga_.setText('')
if self.id_klient > 0 and self.id_pracownik > 0 and self.id_usluga > 0:
self.btn_dodaj.setEnabled(True)
def if_checked(self, txt, q, val=None):
"""
Sprawdza poprawność wprowadzonych damych.
:param val: wartości do zapytania
:param q: zapytanie query MySql
:param txt: komunikat
"""
if self.id_klient < 0 and self.id_pracownik < 0 and self.id_usluga < 0 and self.data is None:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Warning)
msg.setText(txt)
msg.setWindowTitle("Popraw dane")
msg.exec_()
return False
else:
print('Trwa zmiana w bazie danych')
if val:
print('Połączenie')
query_to_db(q, val)
else:
print('Transakcja')
return transaction_to_db(q)
return True
def refresh(self):
"""
Odświeża widok tabeli rezerwacji
"""
# Odświeżanie widoku tabeli
query = QSqlQuery(
'SELECT wizyty.wizyty_id, CONCAT(klienci.imie, " ", klienci.nazwisko) AS klient, uslugi.nazwa, '
'wizyty.rezerwacja_od, wizyty.rezerwacja_do, wizyty.status FROM wizyty,klienci,uslugi WHERE wizyty.klienci_id= klienci.klienci_id AND wizyty.uslugi_id = uslugi.uslugi_id AND wizyty.rezerwacja_od > CURRENT_TIMESTAMP AND wizyty.uzytkownik_id = '
+ str(self.id_pracownik) + ';')
self.model.setQuery(query)
self.view.reset()
def add(self):
"""
Dodaje rezerwację do bazy danych i odświeża widok.
"""
tekst = 'Nie wprowadzono wszystkich danych'
self.data = self.lbl_termin_.dateTime().toString(Qt.ISODate)
self.data_do = datetime.datetime.fromisoformat(
self.data) + datetime.timedelta(
hours=datetime.time.fromisoformat(self.data_do).hour,
minutes=datetime.time.fromisoformat(self.data_do).minute)
# Dodanie nowego użytkownika
query = 'INSERT INTO wizyty (klienci_id, uslugi_id, uzytkownik_id, rezerwacja_od, rezerwacja_do, ' \
'status) VALUES (%s, %s, %s, %s, %s, %s);'
val = (self.id_klient, self.id_usluga, self.id_pracownik, self.data,
str(self.data_do.isoformat()), 'oczekuje')
print(val)
if self.if_checked(tekst, query, val):
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText('Rezerwacja została dodana do bazy danych')
msg.setWindowTitle("Dodano nową rezerwację")
msg.exec_()
self.refresh()
def modify(self):
"""
Zmienia status rezerwacji i odświeża widok.
"""
tekst = 'Nie wprowadzono wszystkich danych'
items = ('Oczekuje', 'Wykonana', 'Rezygnacja')
item, ok = QInputDialog.getItem(self, "Wybierz status",
"Wybierz nowy status rezerwacji",
items, 0, False)
if ok and item:
# Zmodyfikowanie statusu
query = 'UPDATE wizyty SET status = %s WHERE wizyty_id = %s;'
val = (item.lower(), self.id_rezerwacje)
if self.if_checked(tekst, query, val):
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText('Status rezerwacji został zmodyfikowany')
msg.setWindowTitle("Zmodyfikowano status")
msg.exec_()
self.refresh()
def remove(self):
"""
Usuwa rezerwację z bazy danych
"""
test = 'Błąd! Nie można usunąć danej rezerwacji!'
query = 'DELETE FROM wizyty WHERE wizyty_id = %s'
val = (self.id_rezerwacje, )
ret = QMessageBox.question(
self, 'Usuwanie rezerwacji',
"Czy na pewno chcesz usunąć daną rezerwację klienta?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if ret == QMessageBox.Yes:
if self.if_checked(test, query, val):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText('Rezerwacja została usunięta')
msg.setWindowTitle("Usunięto")
msg.exec_()
self.refresh()
@pyqtSlot()
def on_0_clicked(self):
self.lbl_termin_.setTime(self.czas[0])
@pyqtSlot()
def on_1_clicked(self):
self.lbl_termin_.setTime(self.czas[1])
@pyqtSlot()
def on_2_clicked(self):
self.lbl_termin_.setTime(self.czas[2])
@pyqtSlot()
def on_3_clicked(self):
self.lbl_termin_.setTime(self.czas[3])
@pyqtSlot()
def on_4_clicked(self):
self.lbl_termin_.setTime(self.czas[4])
@pyqtSlot()
def on_5_clicked(self):
self.lbl_termin_.setTime(self.czas[5])
@pyqtSlot()
def on_6_clicked(self):
self.lbl_termin_.setTime(self.czas[6])
@pyqtSlot()
def on_7_clicked(self):
self.lbl_termin_.setTime(self.czas[7])
@pyqtSlot()
def on_8_clicked(self):
self.lbl_termin_.setTime(self.czas[8])
@pyqtSlot()
def on_9_clicked(self):
self.lbl_termin_.setTime(self.czas[9])
@pyqtSlot()
def on_10_clicked(self):
self.lbl_termin_.setTime(self.czas[10])
@pyqtSlot()
def on_11_clicked(self):
self.lbl_termin_.setTime(self.czas[11])
@pyqtSlot()
def on_12_clicked(self):
self.lbl_termin_.setTime(self.czas[12])
@pyqtSlot()
def on_13_clicked(self):
self.lbl_termin_.setTime(self.czas[13])
@pyqtSlot()
def on_14_clicked(self):
self.lbl_termin_.setTime(self.czas[14])
@pyqtSlot()
def on_15_clicked(self):
self.lbl_termin_.setTime(self.czas[15])
@pyqtSlot(str)
def searching_u(self, text):
"""
Wyszukuje po wszystkich kolumnach tabeli
:param text:
"""
search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp)
self.proxy_u.setFilterRegExp(search)
# Odpowiedzialne za kolumnę, po której filtruje
self.proxy_u.setFilterKeyColumn(-1)
@pyqtSlot(str)
def searching_k(self, text):
"""
Wyszukuje po wszystkich kolumnach tabeli
:param text:
"""
search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp)
self.proxy_k.setFilterRegExp(search)
# Odpowiedzialne za kolumnę, po której filtruje
self.proxy_k.setFilterKeyColumn(-1)
@pyqtSlot(str)
def searching_p(self, text):
"""
Wyszukuje po wszystkich kolumnach tabeli
:param text:
"""
search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp)
self.proxy_p.setFilterRegExp(search)
# Odpowiedzialne za kolumnę, po której filtruje
self.proxy_p.setFilterKeyColumn(-1)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Nike bot'
self.left = 600
self.top = 300
self.width = 670
self.height = 480
self.all_extensions = ["xlsx", "xlsm", "xlsb", "xls", "xlam"]
self.browser = "firefox"
self.my_threads = []
self.current_date = ''
self.data = []
self.initUI()
# req_proxy = RequestProxy()
# self.proxies = req_proxy.get_proxy_list()
# # self.rus_proxies = []
# for proxy in self.proxies:
# if proxy.country == 'Russian Federation':
# print(proxy.country)
# self.rus_proxies.append(proxy)
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setFixedSize(self.width, self.height)
# Create widget
label = QLabel(self)
self.lable_file = QLabel(self)
self.lable_file.setStyleSheet("background-color:red;")
self.lable_file.setText("File is not uploaded")
self.lable_file.setGeometry(470, 30, 135, 30)
self.button_file = QPushButton(self)
self.button_file.setStyleSheet(
"background-color:#301b28;color:#ddc5a2;")
self.button_file.setGeometry(470, 60, 135, 40)
self.button_file.setText("Brows file")
self.button_file.clicked.connect(lambda: self.openFileNameDialog())
self.button_start = QPushButton(self)
self.button_start.setGeometry(470, 250, 135, 40)
self.button_start.setText("Start")
self.button_start.setStyleSheet(
"background-color:#301b28;color:#ddc5a2;")
self.button_start.clicked.connect(
lambda: self.create_threads(self.browser, self.data))
self.button_start.setDisabled(True)
self.button_close = QPushButton(self)
self.button_close.setStyleSheet(
"background-color:#301b28;color:#ddc5a2;")
self.button_close.setGeometry(470, 290, 135, 40)
self.button_close.setText("Close")
self.button_close.clicked.connect(lambda: self.close_browsers())
self.label_brows = QLabel(self)
self.label_brows.setGeometry(470, 120, 135, 30)
self.label_brows.setStyleSheet("color:#301b28;")
self.label_brows.setText("Choose browser:")
self.combo = QComboBox(self)
self.combo.addItems(["firefox", "chrome", "opera"])
self.combo.setGeometry(470, 150, 135, 40)
self.combo.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
self.combo.activated[str].connect(self.setBrowser)
self.table = QTableWidget(self)
self.table.setGeometry(0, 0, 450, 400)
self.table.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
self.table.setColumnCount(7)
self.table.setRowCount(1)
self.table.setItem(0, 0, QTableWidgetItem("Login"))
self.table.setItem(0, 1, QTableWidgetItem("Password"))
self.table.setItem(0, 2, QTableWidgetItem("Middle name"))
self.table.setItem(0, 3, QTableWidgetItem("Card number"))
self.table.setItem(0, 4, QTableWidgetItem("Date"))
self.table.setItem(0, 5, QTableWidgetItem("Cvv"))
self.table.setItem(0, 6, QTableWidgetItem("Url"))
self.date_field = QDateTimeEdit(self)
self.date_field.setGeometry(470, 350, 165, 40)
self.date_field.setStyleSheet(
"background-color:#301b28;color:#ddc5a2;")
self.date_field.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
self.date_field.setMinimumDateTime(QDateTime.currentDateTime())
self.url = QTextEdit(self)
self.url.setGeometry(10, 430, 400, 30)
self.url.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
self.url_text = QLabel(self)
self.url_text.setGeometry(10, 400, 400, 30)
self.url_text.setStyleSheet("color:#301b28;")
self.url_text.setText("Url:")
self.button_url = QPushButton(self)
self.button_url.setStyleSheet(
"background-color:#301b28;color:#ddc5a2;")
self.button_url.setGeometry(410, 430, 100, 30)
self.button_url.setText("ADD")
self.button_url.clicked.connect(lambda: self.add_url())
self.usr_text = QLabel(self)
self.usr_text.setGeometry(520, 430, 80, 30)
self.usr_text.setStyleSheet("color:#301b28;")
self.usr_text.setText("User count:")
self.users = QTextEdit(self)
self.users.setGeometry(600, 430, 40, 30)
self.users.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
pixmap = QPixmap('static/back.jpeg').scaled(self.width, self.height)
label.setPixmap(pixmap)
self.show()
def openFileNameDialog(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(
self, "QFileDialog.getOpenFileName()", "", "", options=options)
extension = fileName.split(".")[-1]
if fileName and extension in self.all_extensions:
self.start(fileName)
else:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
msg.setText("Wrong file format!")
msg.setInformativeText('Only excel file format')
msg.setWindowTitle("Error")
msg.exec_()
def setBrowser(self, browser):
self.browser = browser
def start(self, name):
self.lable_file.setStyleSheet("background-color:green;")
self.lable_file.setText(" File is uploaded")
self.data = pars_xls(name)
if self.data != "Wrong header params, should be: Login, Password, Middle_name, Card_number, Date, Cvv":
self.table.setRowCount(len(self.data))
self.user_count = len(self.data) - 1
self.users.setText(str(self.user_count))
self.fill_table()
else:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setStyleSheet("background-color:#301b28;color:#ddc5a2;")
msg.setText("Wrong file format!")
msg.setInformativeText(
"Wrong header params, should be: Login, Password, Middle_name, Card_number, Date, Cvv"
)
msg.setWindowTitle("Error")
msg.exec_()
def fill_table(self):
self.table.setItem(0, 0, QTableWidgetItem("Login"))
self.table.setItem(0, 1, QTableWidgetItem("Password"))
self.table.setItem(0, 2, QTableWidgetItem("Middle name"))
self.table.setItem(0, 3, QTableWidgetItem("Card number"))
self.table.setItem(0, 4, QTableWidgetItem("Date"))
self.table.setItem(0, 5, QTableWidgetItem("Cvv"))
self.table.setItem(0, 6, QTableWidgetItem("Url"))
for i in range(len(self.data) - 1):
for j in range(len(self.data[i])):
self.table.setItem(i + 1, j, QTableWidgetItem(self.data[i][j]))
def create_threads(self, browser, data):
self.button_start.setDisabled(True)
k = len(self.my_threads)
self.user_count = int(self.users.toPlainText())
drop_time = int(
datetime.fromisoformat(self.date_field.dateTime().toString(
"yyyy-MM-dd HH:mm:ss")).timestamp())
for i in data:
# proxy = self.rus_proxies[k].get_address()
self.my_threads.append(
bot_on_thread(url=i[6],
browser=browser,
login=i[0],
password=i[1],
middle_name=i[2],
cardNumber=i[3],
cardExpiry=i[4],
cardCvc=i[5],
drop_time=drop_time))
self.my_threads[k].start()
k += 1
if k == self.user_count:
break
def close_browsers(self):
for i in self.my_threads:
try:
i.close_browser()
except:
del i
continue
del i
self.my_threads = []
self.button_start.setDisabled(False)
def add_url(self):
if len(self.data) != 0:
for i in range(len(self.data)):
self.data[i].append(self.url.toPlainText())
self.table.setItem(i + 1, 6,
QTableWidgetItem(self.url.toPlainText()))
self.button_start.setDisabled(False)
print(self.data)
class PhoneLogDlg(QDialog):
FIRST, PREV, NEXT, LAST = range(4)
def __init__(self, parent=None):
super(PhoneLogDlg, self).__init__(parent)
callerLabel = QLabel("&Caller:")
self.callerEdit = QLineEdit()
callerLabel.setBuddy(self.callerEdit)
today = QDate.currentDate()
startLabel = QLabel("&Start:")
self.startDateTime = QDateTimeEdit()
startLabel.setBuddy(self.startDateTime)
self.startDateTime.setDateRange(today, today)
self.startDateTime.setDisplayFormat(DATETIME_FORMAT)
endLabel = QLabel("&End:")
self.endDateTime = QDateTimeEdit()
endLabel.setBuddy(self.endDateTime)
self.endDateTime.setDateRange(today, today)
self.endDateTime.setDisplayFormat(DATETIME_FORMAT)
topicLabel = QLabel("&Topic:")
topicEdit = QLineEdit()
topicLabel.setBuddy(topicEdit)
outcomeLabel = QLabel("&Outcome:")
self.outcomeComboBox = QComboBox()
outcomeLabel.setBuddy(self.outcomeComboBox)
firstButton = QPushButton()
firstButton.setIcon(QIcon(":/first.png"))
prevButton = QPushButton()
prevButton.setIcon(QIcon(":/prev.png"))
nextButton = QPushButton()
nextButton.setIcon(QIcon(":/next.png"))
lastButton = QPushButton()
lastButton.setIcon(QIcon(":/last.png"))
addButton = QPushButton("&Add")
addButton.setIcon(QIcon(":/add.png"))
deleteButton = QPushButton("&Delete")
deleteButton.setIcon(QIcon(":/delete.png"))
quitButton = QPushButton("&Quit")
quitButton.setIcon(QIcon(":/quit.png"))
if not MAC:
addButton.setFocusPolicy(Qt.NoFocus)
deleteButton.setFocusPolicy(Qt.NoFocus)
fieldLayout = QGridLayout()
fieldLayout.addWidget(callerLabel, 0, 0)
fieldLayout.addWidget(self.callerEdit, 0, 1, 1, 3)
fieldLayout.addWidget(startLabel, 1, 0)
fieldLayout.addWidget(self.startDateTime, 1, 1)
fieldLayout.addWidget(endLabel, 1, 2)
fieldLayout.addWidget(self.endDateTime, 1, 3)
fieldLayout.addWidget(topicLabel, 2, 0)
fieldLayout.addWidget(topicEdit, 2, 1, 1, 3)
fieldLayout.addWidget(outcomeLabel, 3, 0)
fieldLayout.addWidget(self.outcomeComboBox, 3, 1, 1, 3)
navigationLayout = QHBoxLayout()
navigationLayout.addWidget(firstButton)
navigationLayout.addWidget(prevButton)
navigationLayout.addWidget(nextButton)
navigationLayout.addWidget(lastButton)
fieldLayout.addLayout(navigationLayout, 4, 0, 1, 2)
buttonLayout = QVBoxLayout()
buttonLayout.addWidget(addButton)
buttonLayout.addWidget(deleteButton)
buttonLayout.addStretch()
buttonLayout.addWidget(quitButton)
layout = QHBoxLayout()
layout.addLayout(fieldLayout)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self.model = QSqlRelationalTableModel(self)
self.model.setTable("calls")
self.model.setRelation(OUTCOMEID, QSqlRelation("outcomes", "id",
"name"))
self.model.setSort(STARTTIME, Qt.AscendingOrder)
self.model.select()
self.mapper = QDataWidgetMapper(self)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.setModel(self.model)
self.mapper.setItemDelegate(QSqlRelationalDelegate(self))
self.mapper.addMapping(self.callerEdit, CALLER)
self.mapper.addMapping(self.startDateTime, STARTTIME)
self.mapper.addMapping(self.endDateTime, ENDTIME)
self.mapper.addMapping(topicEdit, TOPIC)
relationModel = self.model.relationModel(OUTCOMEID)
self.outcomeComboBox.setModel(relationModel)
self.outcomeComboBox.setModelColumn(relationModel.fieldIndex("name"))
self.mapper.addMapping(self.outcomeComboBox, OUTCOMEID)
self.mapper.toFirst()
firstButton.clicked.connect(lambda: self.saveRecord(PhoneLogDlg.FIRST))
prevButton.clicked.connect(lambda: self.saveRecord(PhoneLogDlg.PREV))
nextButton.clicked.connect(lambda: self.saveRecord(PhoneLogDlg.NEXT))
lastButton.clicked.connect(lambda: self.saveRecord(PhoneLogDlg.LAST))
addButton.clicked.connect(self.addRecord)
deleteButton.clicked.connect(self.deleteRecord)
quitButton.clicked.connect(self.done)
self.setWindowTitle("Phone Log")
def done(self, result=None):
self.mapper.submit()
QDialog.done(self, True)
def addRecord(self):
row = self.model.rowCount()
self.mapper.submit()
self.model.insertRow(row)
self.mapper.setCurrentIndex(row)
now = QDateTime.currentDateTime()
self.startDateTime.setDateTime(now)
self.endDateTime.setDateTime(now)
self.outcomeComboBox.setCurrentIndex(
self.outcomeComboBox.findText("Unresolved"))
self.callerEdit.setFocus()
def deleteRecord(self):
caller = self.callerEdit.text()
starttime = self.startDateTime.dateTime().toString(DATETIME_FORMAT)
if (QMessageBox.question(
self, "Delete",
"Delete call made by<br>{0} on {1}?".format(caller, starttime),
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No):
return
row = self.mapper.currentIndex()
self.model.removeRow(row)
self.model.submitAll()
self.model.select()
if row + 1 >= self.model.rowCount():
row = self.model.rowCount() - 1
self.mapper.setCurrentIndex(row)
def saveRecord(self, where):
row = self.mapper.currentIndex()
self.mapper.submit()
if where == PhoneLogDlg.FIRST:
row = 0
elif where == PhoneLogDlg.PREV:
row = 0 if row <= 1 else row - 1
elif where == PhoneLogDlg.NEXT:
row += 1
if row >= self.model.rowCount():
row = self.model.rowCount() - 1
elif where == PhoneLogDlg.LAST:
row = self.model.rowCount() - 1
self.mapper.setCurrentIndex(row)
