def draw(self):
"""
Starts the drawiong process e.g. if the user needs to interact with the map.
"""
if str(self.extentBox.currentText()) == "Draw Rectangle":
if iface.activeLayer():
QMainWindow.hide(self)
self.parent().hide()
if self.parent().parent():
self.parent().parent().hide()
self.drawRectangle = DrawRectangle(iface.mapCanvas(), self)
iface.mapCanvas().setMapTool(self.drawRectangle)
else:
iface.actionPan().trigger()
self.parent().show()
QMainWindow.show(self)
self.iface.messageBar().pushMessage(
"Please open a new layer to get extent from.", duration=5)
elif str(self.extentBox.currentText()) == "Draw Polygon":
if iface.activeLayer():
self.drawBtn.setVisible(True)
QMainWindow.hide(self)
self.parent().hide()
if self.parent().parent():
self.parent().parent().hide()
self.drawPolygon = DrawPolygon(iface.mapCanvas(), self)
iface.mapCanvas().setMapTool(self.drawPolygon)
else:
iface.actionPan().trigger()
self.parent().show()
QMainWindow.show(self)
self.iface.messageBar().pushMessage(
"Please open a new layer to get extent from.", duration=5)
class StreamSelectorView():
"""
StreamSelectorView controls the stream selecting window appearing at the
very beginning, user needs to specify stream number of EEG signals.
"""
def __init__(self):
self.stream_selector_window = QMainWindow()
self.selector_window = stream_slector_layout1.Ui_MainWindow()
self.selector_window.setupUi(self.stream_selector_window)
self.init_GUI()
self.confirm_clicked = True
self.amp_list, self.streamInfos = pu.list_lsl_streams(window=self)
while self.confirm_clicked:
QCoreApplication.processEvents()
# self.stream_selector_window.show()
def init_GUI(self):
"""
Initialize stream selector GUI
"""
self.selector_window.pushButton_confirm.clicked.connect(self.onClicked_pushButton_confirm)
def onClicked_pushButton_confirm(self):
"""
Event listener for confirm button in stream selector GUI.
LSL chooses the typed in stream and pass it to main GUI.
"""
self.confirm_clicked = False
index = int(self.selector_window.lineEdit_stream_selected.text())
amp_name, amp_serial = pu.search_lsl(amp_list=self.amp_list, streamInfos=self.streamInfos, index=index)
variables.Variables.set_amp_name(amp_name)
variables.Variables.set_amp_serial(amp_serial)
self.stream_selector_window.hide()
class Window:
def __init__(self, title: str):
import os
self._window = QMainWindow()
self._window.setWindowTitle(title)
self._window.setWindowIcon(QIcon('resources'+os.sep+'icon.png'))
self._before_close_routine = []
self._window.closeEvent = lambda event: self._close_event_handler()
self._menu_bar = None
self._menu_list = None
self._status_bar = None
def add_status_bar(self):
self._status_bar = self._window.statusBar()
def add_menu(self, title: str):
if self._menu_bar is None:
self._menu_bar = self._window.menuBar()
self._menu_list = {}
self._menu_list[title] = self._menu_bar.addMenu(title)
def add_menu_action(self, menu_title: str, action_name: str, function):
action = QAction(text=action_name, parent=self._window)
action.triggered.connect(function)
self._menu_list[menu_title].addAction(action)
def set_main_layout(self, layout: _Layout):
self._window.setCentralWidget(layout.__widget__())
def bottom_message(self, message: str = 'test'):
if self._status_bar is not None:
self._status_bar.showMessage(message)
def show(self):
self._window.show()
def hide(self):
self._window.hide()
def close(self):
self._window.close()
def _close_event_handler(self):
for method in self._before_close_routine:
method()
def add_method_on_close(self, function):
self._before_close_routine.append(function)
def fix_size(self):
self._window.setFixedSize(self._window.size())
@property
def window_widget(self):
return self._window
class BrowserEdgeWindow(QObject):
def __init__(self, all_nodes, change_manager):
super(BrowserEdgeWindow, self).__init__()
self.all_nodes = all_nodes
self.change_manager = change_manager
# main window
self.w = QMainWindow()
# main window decoration
self.w.setGeometry(0, 0, 640, 900)
self.w.setWindowTitle("Open Similarity Edge")
self.w.setWindowIcon(QIcon(window_icon))
self.w.setWindowModality(Qt.ApplicationModal)
# the browser edge table model
self.browser_edge_table_model = BrowserEdgeTableModel(all_nodes)
# the proxy model
self.proxy_model = QSortFilterProxyModel()
# the browser edge table
self.browser_edge_table = QTableView()
self.browser_edge_table.setSortingEnabled(True)
self.browser_edge_table.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.browser_edge_table.setSelectionMode(
QAbstractItemView.SingleSelection)
self.browser_edge_table.clicked.connect(self._select_index)
self.proxy_model.setSourceModel(self.browser_edge_table_model)
self.browser_edge_table.setModel(self.proxy_model)
self.w.setCentralWidget(self.browser_edge_table)
def show_window(self, edge_records):
self.browser_edge_table_model.set_edge_records(edge_records)
self.w.show()
@pyqtSlot(QModelIndex)
def _select_index(self, model_index):
list_index = self.proxy_model.mapToSource(model_index).row()
edge_record = self.browser_edge_table_model.edge_records[list_index]
node_record1 = self.all_nodes[edge_record.index1 - 1]
node_record2 = self.all_nodes[edge_record.index2 - 1]
print("Open similarity edge")
print(edge_record.text())
self.change_manager.edge_selected_event(edge_record, node_record1,
node_record2)
self.w.hide()
class Applejack(QApplication):
def __init__(self):
QApplication.__init__(self, sys.argv)
self.logWin = QMainWindow()
self.logWin.setMinimumSize(100, 100)
self.logWin.setWindowTitle('Sign in IPM')
self.logWin.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
self.cw = QWidget(self.logWin)
self.logWin.setCentralWidget(self.cw)
self.gl = QGridLayout(self.logWin)
self.cw.setLayout(self.gl)
self.gl.addWidget(QLabel('Login:'******'Password:'******'Log in', self.logWin)
self.gl.addWidget(self.btn, 2, 0)
self.btn.clicked.connect(self.on_click_login)
self.tray = QSystemTrayIcon(self.logWin)
self.tray.setIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
self.logWin.show()
self.tray.show()
def output(self, cond, str):
self.tray.showMessage(cond, str, msecs=5000)
def on_click_login(self):
if self.le.text() != '' and self.pe.text() != '':
self.logWin.hide()
Applet(login=self.le.text(), password=self.pe.text(), fOUT=self.output).start()
class Gui(Ui_UI):
def __init__(self):
super(Gui, self).__init__()
# self.init()
def init(self):
QApplication.setQuitOnLastWindowClosed(False)
self.mainWin = QMainWindow()
self.mainWin.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.setupUi(self.mainWin)
self.timer = self.QTimer
# print("开始gui创建111")
# self.mainWin.show()
self.set_icon()
self.set_menus()
self.set_icon_menus()
@property
def QTimer(self):
return QtCore.QTimer()
def set_icon(self):
self.icon = QSystemTrayIcon(self.mainWin)
try:
# icon_dir = Path("gui")
# url = "{0}{2}{1}{3}{1}{4}{1}{5}".format(icon_dir.path["base"], icon_dir.path["sep"], "UI", "Data", "Assets", "icon.png")
icon_dir = Path("Data")
url = "{0}{2}{1}{3}{1}{4}".format(icon_dir.path["base"],
icon_dir.path["sep"], "statics",
"images", "icon.png")
print(">>>>url", url)
self.icon.setIcon(QIcon(url))
except Exception as err:
print("【err】【Gui ->set_icon】 icon图片文件错误")
def set_menus(self):
self.menu = {}
self.menu["show"] = QAction('&显示(Show)', triggered=self.mainWin.show)
self.menu["hide"] = QAction('&隐藏(Hide)', triggered=self.mainWin.hide)
self.menu["exit"] = QAction('&退出(Exit)', triggered=self.exit)
self.menus = QMenu()
for act in self.menu:
self.menus.addAction(self.menu[act])
def set_icon_menus(self):
self.icon.setContextMenu(self.menus)
self.icon.activated.connect(self.click_btn)
self.icon.show()
print(">>>>show icon")
def click_btn(self, reason):
if reason == 2 or reason == 3:
self.mainWin.show()
def exit(self):
re = QMessageBox.question(self.mainWin, "退出", "是否退出",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if re == QMessageBox.Yes:
self.mainWin.hide()
self.icon.hide()
print("执行GUI退出功能！")
hasattr(self, "exited") and self.exited()
sys.exit(0)
def restart(self):
# if self.main_exit:
# self.main_exit()
python = sys.executable
os.execl(python, python, *sys.argv)
def setExit(self, func):
self.exited = func
def __getitem__(self, item):
return getattr(self, item, None)
def clearText(self, objKey):
# self[objKey].clear()
self.links.clear()
def setText(self, objKey, txt):
Qobject = self[objKey]
Qobject.setText(txt)
def insertText(self, objKey, txt):
Qobject = self[objKey]
Qobject.insertPlainText(txt)
class Controller(Ui_UI):
def __init__(self):
super(Controller, self).__init__()
# self.init()
def init(self):
QApplication.setQuitOnLastWindowClosed(False)
self.mainWin = QMainWindow()
self.mainWin.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.setupUi(self.mainWin)
# print("开始gui创建111")
# self.mainWin.show()
self.set_icon()
self.set_menus()
self.set_icon_menus()
def set_icon(self):
self.icon = QSystemTrayIcon(self.mainWin)
try:
# icon_dir = Path("gui")
# url = "{0}{2}{1}{3}{1}{4}{1}{5}".format(icon_dir.path["base"], icon_dir.path["sep"], "UI", "Data", "Assets", "icon.png")
icon_dir = Path("Data")
url = "{0}{2}{1}{3}{1}{4}".format(icon_dir.path["base"], icon_dir.path["sep"], "statics", "images",
"icon.png")
print(">>>>url", url)
self.icon.setIcon(QIcon(url))
except Exception as err:
print("【err】【Controller ->set_icon】 icon图片文件错误")
def set_menus(self):
self.menu = {}
self.menu["show"] = QAction('&显示(Show)', triggered=self.mainWin.show)
self.menu["hide"] = QAction('&隐藏(Hide)', triggered=self.mainWin.hide)
self.menu["exit"] = QAction('&退出(Exit)', triggered=self.exit)
self.menus = QMenu()
for act in self.menu:
self.menus.addAction(self.menu[act])
def set_icon_menus(self):
self.icon.setContextMenu(self.menus)
self.icon.activated.connect(self.click_btn)
self.icon.show()
print(">>>>show icon")
def click_btn(self, reason):
if reason == 2 or reason == 3:
self.mainWin.show()
def exit(self):
re = QMessageBox.question(self.mainWin, "退出", "是否退出", QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if re == QMessageBox.Yes:
self.mainWin.hide()
self.icon.hide()
print("退出成功")
sys.exit(0)
def restart(self):
# if self.main_exit:
# self.main_exit()
python = sys.executable
os.execl(python, python, *sys.argv)
def txt_run_status(self, info):
self.txtIOCenterLink.setText("状态:" + info)
def txt_run(self, info):
self.txtLogRun.setText(info)
def txt_err(self, info):
self.txtLogErr.setText(info)
def txt_recv(self, info):
self.txtIoReq.setText(info)
def txt_send(self, info):
self.txtIoSend.setText(info)
def txt_web(self, info):
self.txtWeb.setText(info)
class BasicTestQtView(ITestQtView):
"""Main view for the MvcQt application. Inherits from QMainWindow
and implements ITestQtView.
"""
def __init__(self):
"""Constructor."""
super().__init__()
# Constants.
self._WINDOW_WIDTH: int = 250
self._WINDOW_HEIGHT: int = self._WINDOW_WIDTH
# Initialize the main window
self._mainWindow = QMainWindow()
self._mainWindow.setFixedSize(self._WINDOW_WIDTH, self._WINDOW_HEIGHT)
self._mainWindow.setWindowTitle('MvcQt')
# Set the central widget. This is the parent of all widgets.
self._centralWidget = QWidget(self._mainWindow)
self._mainWindow.setCentralWidget(self._centralWidget)
self._layout = QVBoxLayout()
self._centralWidget.setLayout(self._layout)
# Creates a widget to display messages from the model.
self._messageWidget = MessageDisplay()
self._layout.addWidget(self._messageWidget)
self.displayMessage('N/A')
# Create a "Press Me!" button for signaling a message update request.
self._btnPressMe = self._createUpdateMessageButton()
self._layout.addWidget(self._btnPressMe)
@staticmethod
def _createUpdateMessageButton() -> QPushButton:
"""Add a button that prints "Hello!
Returns:
A button that says "Press me!"
"""
prompt: str = 'Press me!'
button = QPushButton(prompt)
button.setSizePolicy(_createExpandingSizePolicy())
return button
def displayMessage(self, message: str):
"""Displays a message to the user.
Args:
message: The message to display to the user.
"""
self._messageWidget.setMessage(message)
print(message)
# Override
def show(self):
self._mainWindow.show()
# Override
def hide(self):
self._mainWindow.hide()
# Override
def registerUpdateMessageRequest(self, callback: Callable):
self._btnPressMe.clicked.connect(callback)
def hideEvent(self, event):
QMainWindow.hide(self)
class RecordReplaySelector():
"""
RecordReplay chooses whether to record new data from device or replay recorded .fif data
"""
def __init__(self):
self.replay_record_window = QMainWindow()
self.mode_window = record_replay.Ui_MainWindow()
self.mode_window.setupUi(self.replay_record_window)
self.init_GUI()
self.replay_record_window.show()
self.button_clicked = False
while not self.button_clicked:
QCoreApplication.processEvents()
def init_GUI(self):
"""
Initialize replay record GUI
"""
self.mode_window.pushButton_record.clicked.connect(
self.onClicked_pushButton_record)
self.mode_window.pushButton_replay.clicked.connect(
self.onClicked_pushButton_replay)
def onClicked_pushButton_record(self):
"""
Event listener for record button.
"""
QCoreApplication.processEvents()
self.button_clicked = True
self.replay_record_window.hide()
def onClicked_pushButton_replay(self):
"""Event listener for replay button"""
self.openFileNameDialog()
def openFileNameDialog(self):
"""
Open folder to choose processed .fif file.
"""
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(None,
"find your .fif file",
r"sample_data/",
"fif files (*.fif)",
options=options)
if fileName:
self.path = fileName
self.run_stream_player()
self.replay_record_window.hide()
self.button_clicked = True
else:
self.path = " "
def run_stream_player(self):
"""Run stream player with selected .fif file"""
server_name = 'StreamPlayer'
chunk_size = 8 # chunk streaming frequency in Hz
print(self.path)
command = [
"python",
"lib\\neurodecode-master\pycnbi\stream_player\stream_player.py",
self.path
]
p = subprocess.Popen(command)
class Main():
filter = None #inicia a variavel com o objecto vazio
def __init__(self):
self.g = Api() # Vai buscar a class API do ficheiro api.py
# Janela Principal
self.main_window = QMainWindow()
self.main_window_form = Ui_MainWindow()
self.main_window_form.setupUi(self.main_window)
self.main_window.show()
# Janela Adicionar
self.main_window2 = QMainWindow()
self.main_window_form2 = Ui_MainWindow2()
self.main_window_form2.setup(self.main_window2)
# Janela Modificar
self.main_window4 = QMainWindow()
self.main_window_form4 = Ui_MainWindow4()
self.main_window_form4.setup4(self.main_window4)
# Janela Pesquisar
self.main_window5 = QMainWindow()
self.main_window_form5 = Ui_MainWindow5()
self.main_window_form5.setup5(self.main_window5)
# Janela Mostrar Imagem
self.main_window6 = QMainWindow()
self.main_window_form6 = Ui_MainWindow6()
self.main_window_form6.setup6(self.main_window6)
self.bindings(
) #chamar a funçao bindings a class , para que os butoes consigam "correr"
self.database(
) #chamar a funcao database, para que mostra a base de dados no inicio
def bindings(self): #Funçao onde se conectao todos os botoes
self.main_window_form.add_pushButton_2.clicked.connect(
self.show_jn2) # mostra a janela "Adicionar"
self.main_window_form2.guardar_pushButton.clicked.connect(
self.guardar
) # quando carrega em guardar corre a funçao "def guardar"
self.main_window_form2.cancelar_pushButton.clicked.connect(
self.hide2
) # quando clica em cancelar corre a funcao "def hide2" que faz esconder a janela
self.main_window_form.remove_pushButton_4.clicked.connect(
self.remover) # quando é clicado corre a funçao "def remover"
self.main_window_form4.novo_cancelar_pushButton.clicked.connect(
self.hide4
) # quando clica em cancelar corre a funcao "def hide4" que faz esconder a janela
self.main_window_form.modify_pushButton_3.clicked.connect(
self.show_jn4
) # mostra a janela da funçao "def show_jn4", quando carregamos em modificar
self.main_window_form4.novo_guardar_pushButton.clicked.connect(
self.modificar
) # quando carregamos em modificar corre a funçao "def modificar"
self.main_window_form2.imagem_pushButton.clicked.connect(self.explorer)
self.main_window_form4.novo_imagem_pushButton.clicked.connect(
self.explorer)
self.main_window_form.search_pushButton.clicked.connect(self.show_jn5)
self.main_window_form5.cancelar_pushButton.clicked.connect(self.hide5)
self.main_window_form6.sair_pushbutton.clicked.connect(self.hide6)
self.main_window_form.treeWidget.doubleClicked.connect(self.show_jn6)
self.main_window_form5.pesquisar_pushButton.clicked.connect(
self.button_pesquisar)
self.main_window_form.reset_pushButton.clicked.connect(
self.update_database
) #quando se clicla no botao reset conecta-se a funçao "def clear_database"
self.main_window_form5.preco_checkBox.clicked.connect(
self.ativa_precos)
self.main_window_form5.data_checkBox.clicked.connect(self.ativa_data)
self.main_window_form.exportar_pushButton.clicked.connect(
self.extrair_csv)
self.main_window_form.importar_pushButton.clicked.connect(
self.import_csv)
def guardar(self):
inp = self.main_window_form2.preco_lineEdit.text(
) # guarda o input de preço em inp
try:
preco = float(inp) # verifica se preço é um float
except ValueError: # Se nao for, aparece uma janela de "Erro!", e repete o processo
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("O valor é invalido!")
msg.exec_()
return
if self.main_window_form2.nome_lineEdit.text(
) == "": #se o nome estiver em branco, mostra uma mensagem, e repete o processo
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("Tem de introduzir um Nome")
msg.exec_()
return
if self.main_window_form2.marca_lineEdit.text() == "":
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("Tem de introduzir uma Marca")
msg.exec_()
return
if self.main_window_form2.imagem_lineEdit.text() == "":
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("Tem de introduzir uma Imagem!")
msg.exec_()
return
self.g.add_artigo(nome=self.main_window_form2.nome_lineEdit.text(),
marca=self.main_window_form2.marca_lineEdit.text(),
preco=preco,
imagem=self.main_window_form2.imagem_lineEdit.text()
) # funçao que corre na "api.py" "def add_artigo"
self.hide2()
self.update_database(
) #insere-a de novo com as alteraçoes feitas pelo utilizador
def remover(self):
get_Selected = self.main_window_form.treeWidget.selectedItems(
) # seleção do artigo que o utilizador pretende
if get_Selected: # se selecionada
remove = get_Selected[0].text(0) # vai buscar o artigo selecionado
self.g.remove_artigo(remove) # remove o artigo
self.update_database() #limpa, e insere a base de dados na treewidget
def modificar(self):
inp = self.main_window_form4.novo_preco_lineEdit.text(
) #a ediçao do preco é contida na variavel inp
try: #utilizador tenta introduzir um float, caso de erro aparece uma menssagem "O valor é invalido"
preco = float(inp) #variavel tranformada para um float
except ValueError:
msg = QMessageBox(
) #Introduz na variavel msg a janela de texto(widget do pyqt5)
msg.setWindowTitle("Erro!") #Titulo da janela de texto
msg.setText(
"O valor é invalido!") #Introduz a Menssagem que queremos
msg.exec_() #executa
return #volta a repetir o processo sem parar o programa
get_modificar = self.main_window_form.treeWidget.selectedItems(
) # seleção do artigo que o utilizador pretende
if get_modificar: #se o artigo for selecionado
artigo_selecionado = get_modificar[0].text(
0) #artigo selecionado com o texto que a seleçao se identifica
if self.main_window_form4.novo_nome_lineEdit.text(
) == "": #na janela modificar, se a linha onde se introduz o nome estiver em branco
msg = QMessageBox(
) #Introduz na variavel msg a janela de texto(widget do pyqt5)
msg.setWindowTitle("Erro!") #Titulo da janela de texto
msg.setText(
"Introduza um Nome") #Introduz a Menssagem que queremos
msg.exec_() #executa
return #volta a repetir o processo sem parar o programa
if self.main_window_form4.novo_marca_lineEdit.text() == "":
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("Introduza uma Marca")
msg.exec_()
return
if self.main_window_form4.novo_imagem_lineEdit.text() == "":
msg = QMessageBox()
msg.setWindowTitle("Erro!")
msg.setText("Introduza uma Imagem")
msg.exec_()
return
self.g.modificar_artigo(
artigo_selecionado,
novo_nome=self.main_window_form4.novo_nome_lineEdit.text(),
novo_marca=self.main_window_form4.novo_marca_lineEdit.text(),
novo_preco=preco,
novo_imagem=self.main_window_form4.novo_imagem_lineEdit.text())
#inicia a funçao que esta na api.Api() def modificar_artigo, em que, o artigo selecionado
self.hide4(
) #inicia a def hide4, que faz esconder a janela depois de modificar
self.update_database(
) #introduz a funçao def resest_database, para introduzir de novo a base de dados com as alterações
def explorer(self):
file = QFileDialog(
) #class que promove que os utilizadores permitam a selecao de ficheiros ou diretório
file.setFileMode(QFileDialog.ExistingFile) #o ficheiro tem de existir
if file.exec_(): # se a procura de ficheiros incia
filenames = file.selectedFiles(
) #os ficheiros selecionados(o diretorio), terao como variavel "filenames"
self.main_window_form2.imagem_lineEdit.setText(
filenames[0]) #para a linha de ediçao da janela
# main_windows_form2(janela de adicionar), com o nome imagem_lineedit, insere o texto da variavel filenames
self.main_window_form4.novo_imagem_lineEdit.setText(
filenames[0]) #repete-se a mesma coisa para a janela Modificar
def pesquisar(self):
self.main_window_form5.min_doubleSpinBox.setDisabled(
True) #Desativar o preco minimo
self.main_window_form5.max_doubleSpinBox.setDisabled(
True) #Desativar o preço maximo
self.main_window_form5.min_dateTimeEdit.setDisabled(
True) #Desativar a data minima
self.main_window_form5.max_dateTimeEdit.setDisabled(
True) #Desativar a data maxima
nome = db.session.query(db.Artigo.nome).all(
) #vai buscar todos os artigos.nome da base de dados e introduz na variavel nome
self.main_window_form5.nome_comboBox.clear(
) #apaga tudo o que tiver na combobox da janela pesquisar
self.main_window_form5.nome_comboBox.addItem(
""
) #adiciona um item em branco, para que seja possivel pesquisar uma marca ou preço, sem introduzir um nome
lista_nome = [] #cria uma lista
for i in nome: #para a variavel i em nome faz:
if i not in lista_nome: #se i nao está na lista_nome
lista_nome.append(
i
) #adiciona i à lista_nome, ou seja, i esta dentro da variavel nome
self.main_window_form5.nome_comboBox.addItem(
i[0]) #adiciona i a combobox Nome:
self.main_window_form5.nome_comboBox.setCurrentText(
None
) #para combobox nome na janela pesquisar, para o valor inicial nao ira ter nenhum objecto atribuido
#Isto é para a combobox do nome e marca, apaga tudo, adiciona uma string em branco, verifica se os objectos da lista
#sao repetidos, se nao forem adiciona, se forem nem se quer aparecem, e o ojecto inical é nenhum(None)
marca = db.session.query(db.Artigo.marca).all()
self.main_window_form5.marca_comboBox.clear()
self.main_window_form5.marca_comboBox.addItem("")
lista_marca = []
for i in marca:
if i not in lista_marca:
lista_marca.append(i)
self.main_window_form5.marca_comboBox.addItem(i[0])
self.main_window_form5.marca_comboBox.setCurrentText(None)
#É a mesma coisa que o nome, mas agora para a marca
def ativa_precos(self):
if self.main_window_form5.preco_checkBox.isChecked(
): #se a checkbox estiver com o visto
self.main_window_form5.min_doubleSpinBox.setEnabled(
True) #ativa a min_doublespinbox
self.main_window_form5.max_doubleSpinBox.setEnabled(
True) #ativa a max_doublespinbox
else: #se nao estiver com o visto
self.main_window_form5.min_doubleSpinBox.setEnabled(
False) #desativa
self.main_window_form5.max_doubleSpinBox.setEnabled(False)
def ativa_data(self): #é igual a função do ativa_precos so que para a data
if self.main_window_form5.data_checkBox.isChecked():
self.main_window_form5.min_dateTimeEdit.setEnabled(True)
self.main_window_form5.max_dateTimeEdit.setEnabled(True)
else:
self.main_window_form5.min_dateTimeEdit.setEnabled(False)
self.main_window_form5.max_dateTimeEdit.setEnabled(False)
def button_pesquisar(self):
nome = self.main_window_form5.nome_comboBox.currentText(
) # retira o valor contido no nome da janela pesquisar
marca = self.main_window_form5.marca_comboBox.currentText(
) # retira o valor contido na marca da janela pesquisar
if self.main_window_form5.preco_checkBox.isChecked(
): #se a checkbox tiver o visto
preco_min = self.main_window_form5.min_doubleSpinBox.value(
) #retira o valor que esta inserido e mete-o na variavel preco_min
preco_max = self.main_window_form5.max_doubleSpinBox.value(
) #retira o valor que esta inserido e mete-o na variavel preco_max
else: #se nao tiver o visto
preco_min = None #preco_min é igual a None
preco_max = None #preco_max é igual a None
#repete-se para a data
if self.main_window_form5.data_checkBox.isChecked():
data_min = self.main_window_form5.min_dateTimeEdit.date(
) #Imprime a data "PyQt5.QtCore.QDate(2019, 05, 20)"
datascrap_min = data_min.toPyDate() #Imprime 2019-05-20
data_max = self.main_window_form5.max_dateTimeEdit.date(
) #Imprime a data "PyQt5.QtCore.QDate(2019, 05, 20)"
datascrap_max = data_max.toPyDate() #Imprime 2019-05-20
else:
datascrap_min = None
datascrap_max = None
self.filter = {
"nome": nome,
"marca": marca,
"preco": [preco_min, preco_max],
"datascrap": [datascrap_min, datascrap_max]
}
self.hide5() #esconde a janela de pesquisa
self.database() #insere a base de dados
def database(self):
if self.filter is not None: #se houver filtro
artigo = db.session.query(
db.Artigo) #manda um query a base de dados
if self.filter["nome"]: #se filtro for no nome
query = db.session.query(db.Artigo).filter_by(
nome=self.filter["nome"]
) #manda um query a base de dados para filtrar por nome
artigo = artigo.intersect(
query
) #tudo o que estiver na base de dados é interceptado com o query do nome
if self.filter["marca"]:
query = db.session.query(
db.Artigo).filter_by(marca=self.filter["marca"])
artigo = artigo.intersect(query)
if self.filter["preco"][0] is not None or self.filter["preco"][
1] is not None:
query = db.session.query(db.Artigo).filter(db.Artigo.preco >= self.filter["preco"][0])\
.filter(db.Artigo.preco <= self.filter["preco"][1]) #recolhe todos os valor que estao entre o preço minimo e o preço maximo
artigo = artigo.intersect(query) #interceção dos artigos
if self.filter["datascrap"][0] is not None or self.filter[
"datascrap"][1] is not None:
query = db.session.query(db.Artigo).filter(db.Artigo.data_scrap >= self.filter["datascrap"][0])\
.filter(db.Artigo.data_scrap <= self.filter["datascrap"][1]) # recolhe todas as datas, entre as datas escolhidas
artigo = artigo.intersect(query)
else: #se nao tiver filtros
artigo = db.session.query(db.Artigo).all(
) #manda um pedido a base de dados para recolher todos os artigos que se encontram na db.Artigo
self.main_window_form.treeWidget.clear(
) #limpa a janela que mostra a base de dados
for i in artigo: #para i em artigos
item = QTreeWidgetItem([
str(i.id), i.nome, i.marca,
str(i.preco),
str(i.data_scrap).split(" ")[0],
str(i.imagem)
])
self.main_window_form.treeWidget.addTopLevelItem(
item
) #adiciona a janela de demostração os items recolhidos em artigos
def update_database(
self
): #limpa a janela de visualizaçao da database e insere-a de novo
artigo = db.session.query(db.Artigo).all()
self.main_window_form.treeWidget.clear()
for i in artigo:
item = QTreeWidgetItem([
str(i.id), i.nome, i.marca,
str(i.preco),
str(i.data_scrap).split(" ")[0],
str(i.imagem)
])
self.main_window_form.treeWidget.addTopLevelItem(item)
def extrair_csv(self):
if self.filter is not None:
artigo = db.session.query(
db.Artigo) # manda um query a base de dados
if self.filter["nome"]: # se filtro for no nome
query = db.session.query(db.Artigo).filter_by(
nome=self.filter["nome"]
) # manda um query a base de dados para filtrar por nome
artigo = artigo.intersect(
query
) # tudo o que estiver na base de dados é interceptado com o query do nome
if self.filter["marca"]:
query = db.session.query(
db.Artigo).filter_by(marca=self.filter["marca"])
artigo = artigo.intersect(query)
if self.filter["preco"][0] is not None or self.filter["preco"][
1] is not None:
query = db.session.query(db.Artigo).filter(db.Artigo.preco >= self.filter["preco"][0]) \
.filter(db.Artigo.preco <= self.filter["preco"][1]) # recolhe todos os valor que estao entre o preço minimo e o preço maximo
artigo = artigo.intersect(query) # interceção dos artigos
if self.filter["datascrap"][0] is not None or self.filter[
"datascrap"][1] is not None:
query = db.session.query(db.Artigo).filter(db.Artigo.data_scrap >= self.filter["datascrap"][0]) \
.filter(db.Artigo.data_scrap <= self.filter["datascrap"][1]) # recolhe todas as datas, entre as datas escolhidas
artigo = artigo.intersect(query)
else: # se nao tiver filtros
artigo = db.session.query(db.Artigo).all()
file = './Ficheiros/export.csv'
with open(file, 'w') as csvfile:
outcsv = csv.writer(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
cabecalho = db.Artigo.__table__.columns.keys()
outcsv.writerow(cabecalho)
for gravar in artigo:
outcsv.writerow([getattr(gravar, c) for c in cabecalho])
msg = QMessageBox()
msg.setWindowTitle("Verificação!")
msg.setText("O seu ficheiro foi exportado")
msg.exec_()
def import_csv(self):
import_csv()
self.update_database()
def show_jn2(self):
self.main_window2.show() # mostrar a janela Adicionar
def show_jn4(
self
): #imprime os campos na janela de modificar, o artigo selecionado
get_Selected = self.main_window_form.treeWidget.selectedItems()
if get_Selected:
id = get_Selected[0].text(0)
artigo = db.session.query(db.Artigo).filter_by(id=id).first()
self.main_window_form4.novo_nome_lineEdit.setText(artigo.nome)
self.main_window_form4.novo_marca_lineEdit.setText(artigo.marca)
self.main_window_form4.novo_preco_lineEdit.setText(
str(artigo.preco))
self.main_window_form4.novo_imagem_lineEdit.setText(
str(artigo.imagem))
self.main_window4.show() # mostra a janela
def show_jn5(self):
self.main_window5.show() # mostra a janela do pesquisar
self.pesquisar()
def show_jn6(self):
get_Selected = self.main_window_form.treeWidget.selectedItems(
) # seleção do artigo que o utilizador pretende
if get_Selected: # se selecionada
id = get_Selected[0].text(
0) # regista id da seleçao e guarda na variavel id
artigo = db.session.query(db.Artigo).filter_by(id=id).first()
self.main_window_form6.id_lineEdit.setText(
str(artigo.id)
) # apresenta o id do artigo selecionado é convertido em str
# para visualizar, porque verdadeiramente o id é um inteiro como se pode ver na pasta api.py
self.main_window_form6.nome_lineEdit.setText(
artigo.nome) # apresenta o nome do artigo selecionado
self.main_window_form6.marca_lineEdit.setText(
artigo.marca) # apresenta a marca do artigo selecionado
self.main_window_form6.preco_lineEdit.setText(str(artigo.preco))
self.main_window_form6.datascrap_lineEdit.setText(
str(artigo.data_scrap))
self.main_window_form6.imagem_lineEdit.setText(str(artigo.imagem))
pixmap = QPixmap(
artigo.imagem
) # "converte" o directorio, para a variavel pixmap
pixmap = pixmap.scaled(
400, 400
) #redimensiona a foto para 400*400 que é o tamanho da "label"
self.main_window_form6.imagem_label.setPixmap(
pixmap
) # apresenta a imagem na label(widget utilizado no qtdesigner)
self.main_window6.show() #mostra a janela do artigo selecionado
def hide2(self):
self.main_window2.hide() # esconde a janela
def hide4(self):
self.main_window4.hide() # esconde a janela
def hide5(self):
self.main_window5.hide()
def hide6(self):
self.main_window6.hide()
def run_myScript(self):
call(["python", 'PlotterScipt.py'])
QMainWindow.hide()
def hide(self):
self.update_account_refreshtime = 60000
self.timer.start(self.update_account_refreshtime)
QMainWindow.hide(self)
