class AddAssetDialog(QDialog, Ui_AddAssetDialog):
def __init__(self, parent, db, symbol):
QDialog.__init__(self)
self.setupUi(self)
self.db = db
self.asset_id = None
self.SymbolEdit.setText(symbol)
self.type_model = QSqlTableModel(db=db)
self.type_model.setTable('asset_types')
self.type_model.select()
self.TypeCombo.setModel(self.type_model)
self.TypeCombo.setModelColumn(1)
self.data_src_model = QSqlTableModel(db=db)
self.data_src_model.setTable('data_sources')
self.data_src_model.select()
self.DataSrcCombo.setModel(self.data_src_model)
self.DataSrcCombo.setModelColumn(1)
# center dialog with respect to parent window
x = parent.x() + parent.width()/2 - self.width()/2
y = parent.y() + parent.height()/2 - self.height()/2
self.setGeometry(x, y, self.width(), self.height())
def accept(self):
self.asset_id = addNewAsset(self.db, self.SymbolEdit.text(), self.NameEdit.text(),
self.type_model.record(self.TypeCombo.currentIndex()).value("id"),
self.isinEdit.text(),
self.data_src_model.record(self.DataSrcCombo.currentIndex()).value("id"))
super().accept()
def update_torna_settings(self):
torna_settings_model = QSqlTableModel(db=db)
torna_settings_model.setTable("torna_settings")
record = torna_settings_model.record()
torna_settings_model.select()
# for x in range(torna_settings_model.rowCount()):
# record.setGenerated(x, False)
record.setValue(0, self.torna_id)
record.setValue(1, self.torna_name.text())
if self.is_roundrobin.isChecked():
record.setValue(2, 1)
else:
record.setValue(2, 0)
record.setValue(3, self.csoport_number.value())
record.setValue(4, self.jatekos_per_csoport.value())
record.setValue(5, self.variant.value())
if self.is_sets.isChecked():
record.setValue(6, 1)
else:
record.setValue(6, 0)
record.setValue(7, self.sets_number.value())
record.setValue(8, self.legs_number.value())
if self.is_best.isChecked():
record.setValue(9, 1)
else:
record.setValue(9, 0)
if self.is_draw.isChecked():
record.setValue(10, 1)
else:
record.setValue(10, 0)
record.setValue(11, self.pont_win.value())
record.setValue(12, self.pont_draw.value())
record.setValue(13, self.pont_lost.value())
if self.is_single_elim.isChecked():
record.setValue(14, 1)
else:
record.setValue(14, 0)
record.setValue(15, self.num_single.value())
if self.is_3place.isChecked():
record.setValue(16, 1)
else:
record.setValue(16, 0)
record.setValue(17, self.leg_num_single.value())
record.setValue(18, self.leg_num_semifinal.value())
record.setValue(19, self.leg_num_3place.value())
record.setValue(20, self.leg_num_final.value())
record.setValue(21, 2)
for i in range(torna_settings_model.rowCount()):
if torna_settings_model.record(i).value(0) == self.torna_id:
# print(torna_settings_model.record(i).value(0), ":", i)
record_number = i
# print(record)
if torna_settings_model.setRecord(record_number, record):
torna_settings_model.submitAll()
else:
db.rollback()
def new_kiadas(self):
self.kiadas_form_window = KiadasFormDialog()
self.kiadas_form_window.setWindowTitle("Új kiadás rögzítése")
self.kiadas_form_window.show()
model = QSqlTableModel()
model.setTable("kassza")
record = model.record()
record.remove(record.indexOf('id'))
if self.kiadas_form_window.exec_():
mezo_rekord = []
for i in range(len(self.kiadas_form_window.mezo_ertekek)):
if i != 4:
mezo_rekord.append(
self.kiadas_form_window.mezo_ertekek[i].text())
else:
mezo_rekord.append(
int(self.kiadas_form_window.mezo_ertekek[i].text()) *
-1)
for i in range(len(mezo_rekord)):
record.setValue(i, mezo_rekord[i])
if model.insertRecord(-1, record):
model.submitAll()
else:
db.rollback()
def accept(self):
if self.uj_station:
now = QDateTime.currentDateTime()
network = QSqlTableModel()
network.setTable("reged_station")
rec_net = network.record()
rec_net.remove(0)
rec_net.setValue(0, self.station.text())
rec_net.setValue(1, self.ip.text())
rec_net.setValue(2, self.token.text())
rec_net.setValue(3, now)
if network.insertRecord(-1, rec_net):
network.submitAll()
else:
db.rollback()
self.uj_station = False
if self.valtozott:
# Módosítani a db-t és a config.ini-t
# config.ini update
config.set('DEFAULT', 'secret key', self.token.text())
config.set('DEFAULT', 'station ip', self.ip.text())
config.set('DEFAULT', 'station id', self.station.text())
with open('config.ini', 'w') as configfile:
config.write(configfile)
# db update
now = QDateTime.currentDateTime().toString(
"yyyy-MM-ddThh:mm:ss.sss")
model3 = QSqlQueryModel()
query3 = QSqlQuery(
f"update reged_station set station_id='{self.station.text()}', station_ip='{self.ip.text()}', timestamp='{now}' where secret_key='{self.token.text()}'",
db=db)
model3.setQuery(query3)
self.valtozott = False
super().accept()
class CurrencyCombo(QComboBox):
def __init__(self, parent):
QComboBox.__init__(self, parent)
self.model = None
def init_db(self, db):
self.model = QSqlTableModel(db=db)
self.model.setTable('currencies')
self.model.select()
self.setModel(self.model)
self.setModelColumn(1)
self.setCurrentIndex(self.findText(get_base_currency_name(db)))
def selected_currency(self):
return self.model.record(self.currentIndex()).value("id")
def selected_currency_name(self):
return self.model.record(self.currentIndex()).value("name")
class AddAssetDialog(QDialog, Ui_AddAssetDialog):
def __init__(self, symbol, isin='', name=''):
QDialog.__init__(self)
self.setupUi(self)
self.asset_id = None
self.SymbolEdit.setText(symbol)
self.isinEdit.setText(isin)
self.NameEdit.setText(name)
self.type_model = QSqlTableModel(db=db_connection())
self.type_model.setTable('asset_types')
self.type_model.select()
self.TypeCombo.setModel(self.type_model)
self.TypeCombo.setModelColumn(1)
self.data_src_model = QSqlTableModel(db=db_connection())
self.data_src_model.setTable('data_sources')
self.data_src_model.select()
self.DataSrcCombo.setModel(self.data_src_model)
self.DataSrcCombo.setModelColumn(1)
# center dialog with respect to main application window
parent = None
for widget in QApplication.topLevelWidgets():
if widget.objectName() == Setup.MAIN_WND_NAME:
parent = widget
if parent:
x = parent.x() + parent.width() / 2 - self.width() / 2
y = parent.y() + parent.height() / 2 - self.height() / 2
self.setGeometry(x, y, self.width(), self.height())
def accept(self):
self.asset_id = JalDB().add_asset(
self.SymbolEdit.text(), self.NameEdit.text(),
self.type_model.record(self.TypeCombo.currentIndex()).value("id"),
self.isinEdit.text(),
self.data_src_model.record(
self.DataSrcCombo.currentIndex()).value("id"))
super().accept()
def new_berlet(self):
self.berlet_form_window = BerletFormDialog()
self.berlet_form_window.setWindowTitle("Bérlet vásárlás")
self.berlet_form_window.show()
model = QSqlTableModel()
model.setTable("kassza")
record = model.record()
record.remove(record.indexOf('id'))
if self.berlet_form_window.exec_():
for i in range(len(self.berlet_form_window.mezo_ertekek)):
record.setValue(i,
self.berlet_form_window.mezo_ertekek[i].text())
if model.insertRecord(-1, record):
model.submitAll()
else:
db.rollback()
class CurrencyComboBox(QComboBox):
changed = Signal(int)
def __init__(self, parent):
QComboBox.__init__(self, parent)
self.p_selected_id = 0
self.model = None
self.table_name = 'currencies'
self.field_name = 'name'
self.activated.connect(self.OnUserSelection)
self.model = QSqlTableModel(db=db_connection())
self.model.setTable(self.table_name)
self.model.select()
self.setModel(self.model)
self.setModelColumn(self.model.fieldIndex(self.field_name))
def isCustom(self):
return True
def getId(self):
return self.p_selected_id
def setId(self, new_id):
if self.p_selected_id == new_id:
return
self.p_selected_id = new_id
name = get_field_by_id_from_table(self.table_name, self.field_name,
self.p_selected_id)
if self.currentIndex() == self.findText(name):
return
self.setCurrentIndex(self.findText(name))
selected_id = Property(int, getId, setId, notify=changed, user=True)
def setIndex(self, index):
if index is not None:
self.selected_id = index
self.changed.emit(self.selected_id)
@Slot()
def OnUserSelection(self, _selected_index):
self.selected_id = self.model.record(self.currentIndex()).value("id")
self.changed.emit(self.selected_id)
def new_adomany(self):
self.adomany_form_window = AdomanyFormDialog()
self.adomany_form_window.setWindowTitle("Adomány befizetés")
self.adomany_form_window.show()
model = QSqlTableModel()
model.setTable("kassza")
record = model.record()
record.remove(record.indexOf('id'))
if self.adomany_form_window.exec_():
mezo_rekord = []
for i in range(len(self.adomany_form_window.mezo_ertekek)):
mezo_rekord.append(
self.adomany_form_window.mezo_ertekek[i].text())
for i in range(len(mezo_rekord)):
record.setValue(i, mezo_rekord[i])
if model.insertRecord(-1, record):
model.submitAll()
else:
db.rollback()
def accept(self):
params = []
m_id = p1_id = p2_id = set = leg = hc1 = hc2 = 0
var = ""
player1 = self.input_player1_name.text()
player2 = self.input_player2_name.text()
# todo A MATCH_ID-T VALAMI EGYEDI MÓDON KELL GENERÁLNI(pl. az időbélyeg bizonyos részével)
m_id = random.randint(10, 1000000)
leg = self.spin_legs.value()
set = self.spin_sets.value()
hc1 = self.handi1.value()
hc2 = self.handi2.value()
if self.gomb_301.isChecked():
var = "301"
elif self.gomb_401.isChecked():
var = "401"
elif self.gomb_501.isChecked():
var = "501"
else:
var = "701"
if self.best_of.isChecked():
bestof = 1
else:
bestof = 0
if len(player1) == 0:
p1_id = 1
player1 = "Player 1"
else:
player1_id_model = QSqlQueryModel()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}' and type='local' and aktiv=1",
db=db)
player1_id_model.setQuery(query1)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
if player1_id_model.record(0).value(0):
p1_id = int(player1_id_model.record(0).value(0))
else:
# todo beszúrás előtt ellenőritni, hogy egyedi-e. Létezhet versenyen felvitt ugyanolyan név
player_model1 = QSqlTableModel()
player_model1.setTable("players")
rec_play1 = player_model1.record()
rec_play1.remove(0)
rec_play1.setValue(0, player1)
rec_play1.setValue(1, 'local')
rec_play1.setValue(2, 1)
if player_model1.insertRecord(-1, rec_play1):
player_model1.submitAll()
else:
db.rollback()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}' and type='local' and aktiv=1",
db=db)
player1_id_model.setQuery(query1)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
p1_id = int(player1_id_model.record(0).value(0))
if len(player2) == 0:
p2_id = 2
player2 = "Player 2"
else:
player2_id_model = QSqlQueryModel()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}' and type='local' and aktiv=1",
db=db)
player2_id_model.setQuery(query2)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
if player2_id_model.record(0).value(0):
p2_id = int(player2_id_model.record(0).value(0))
else:
player_model2 = QSqlTableModel()
player_model2.setTable("players")
rec_play2 = player_model2.record()
rec_play2.remove(0)
rec_play2.setValue(0, player2)
rec_play2.setValue(1, 'local')
rec_play2.setValue(2, 1)
if player_model2.insertRecord(-1, rec_play2):
player_model2.submitAll()
else:
db.rollback()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}' and type='local' and aktiv=1",
db=db)
player2_id_model.setQuery(query2)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
p2_id = int(player2_id_model.record(0).value(0))
# Match paremeterek rögzítése
now = QDateTime.currentDateTime()
match_model = QSqlTableModel()
match_model.setTable("match_settings")
# todo Best Of... nincs db-ben tárolva
record = match_model.record()
record.setValue(0, m_id)
record.setValue(1, p1_id)
record.setValue(2, p2_id)
record.setValue(3, var)
record.setValue(4, leg)
record.setValue(5, set)
record.setValue(6, hc1)
record.setValue(7, hc2)
record.setValue(8, now)
if match_model.insertRecord(-1, record):
match_model.submitAll()
else:
db.rollback()
params.append(player1)
params.append(player2)
params.append(m_id)
params.append(p1_id)
params.append(p2_id)
params.append(var)
params.append(leg)
params.append(set)
params.append(hc1)
params.append(hc2)
params.append(bestof)
self.parent.new_game_window.params = params
self.parent.new_game_window.refresh()
super().accept()
class VentanaPrincipal(QTabWidget):
def __init__(self):
super(VentanaPrincipal, self).__init__()
self.ui = Ui_TabWidget()
self.ui.setupUi(self)
# DB
self.db = QSqlDatabase.addDatabase("QSQLITE")
self.db.setDatabaseName("cuentas.db")
self.conector = QSqlDatabase.database()
self.general_query = QSqlQuery()
self.organizar_db()
# Querys para psw_tool
self.master_query = QSqlQuery()
self.save_query = QSqlQuery()
self.passwords_query_retrieve = QSqlQuery()
self.passwords_query_write = QSqlQuery()
self.popular = QSqlQuery()
self.comboBoxes_query_categoria = QSqlQuery()
self.comboBoxes_query_mail = QSqlQuery()
self.comboBoxes_query_usuario = QSqlQuery()
self.verificar_columna_contrasenas = QSqlQuery()
self.filtro = QSqlQuery()
# Querys para pswItemDelegate
self.all_data = QSqlQuery()
# BASE DE DATOS en UI
self.model = QSqlTableModel() # pswItemDelegate.CustomSqlModel()
self.organizar_tabla_ui()
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit) # Va aca abajo por self.model.setTable('passwords')
# Para cuando se cambian datos
self.model.dataChanged.connect(self.celdas_cambiadas)
self.ui.tabla_db.setContextMenuPolicy(Qt.CustomContextMenu)
self.ui.tabla_db.customContextMenuRequested.connect(self.context_menu)
# Filtro DB
# .connect(lambda: self.
self.tabBarClicked.connect(self.actualizar_tabs)
# Iconos DB en UI
self.icon_seguridad = QIcon()
self.icon_seguridad.addPixmap(QPixmap(":/media/iconografia/locked.png"), QIcon.Normal, QIcon.Off)
self.icon_desbloqueado = QIcon()
self.icon_desbloqueado.addPixmap(QPixmap(":/media/iconografia/unlocked.png"), QIcon.Normal, QIcon.Off)
self.icon_editar = QIcon()
self.icon_editar.addPixmap(QPixmap(":/media/iconografia/pencil.png"), QIcon.Normal, QIcon.Off)
self.icon_guardar = QIcon()
self.icon_guardar.addPixmap(QPixmap(":/media/iconografia/broken-pencil.png"), QIcon.Normal, QIcon.Off)
# Procesos iniciales
self.cargar_config()
self.master_key = None
self.seguridad_alterada = False
self.candado = "cerrado"
self.modo_boton_editar_guardar = "editar"
self.contrasenas_nuevas = {}
self.edits = {}
self.revisar_columna_contrasenas()
self.cargar_opciones_combo_boxes()
# Alertas
# Iconos para las alertas sin UI
self.icon_ventana = QIcon()
self.icon_ventana.addPixmap(QPixmap(":/media/imagenes/main_frame.png"), QIcon.Normal, QIcon.Off)
self.alerta_config = QMessageBox(QMessageBox.Warning,
"Problema con la configuración actual",
"Existen dos posibilidades para este error:\n\n1. El archivo de configuración está dañando\n2. Usted tiene todas las opciones desmarcadas (el amor no cuenta)\n\nPara solucionarlo, borre el archivo de configuración ('opciones.ini'),\no marque alguna opción en la pestaña de configuración y guarde su selección\n"
)
self.alerta_master_psw_mala = QMessageBox(QMessageBox.Warning,
"Problema con la contraseña ingresada",
"Por favor tome precauciones con la elección de la contraseña maestra.\nPara poder proseguir debe ingresar una contraseña con más de 5 y menos de 17 caracteres, o sino presione cancelar."
)
self.alerta_master_psw_incorrecta = QMessageBox(QMessageBox.Warning,
"Problema con la contraseña ingresada",
"La contraseña que ingresaste es incorrecta"
)
self.alerta_guardado_exitoso = QMessageBox(QMessageBox.Information, "Información guardada",
"Toda la información que ingresaste se guardó con éxito."
)
self.alerta_config.setWindowIcon(self.icon_ventana)
self.alerta_master_psw_mala.setWindowIcon(self.icon_ventana)
self.alerta_master_psw_incorrecta.setWindowIcon(self.icon_ventana)
self.alerta_guardado_exitoso.setWindowIcon(self.icon_ventana)
# Alertas con su propia UI
# Dialog info
self.dialogo_info = QDialog()
self.info_app = Ui_dialogo_info()
self.info_app.setupUi(self.dialogo_info)
# Alerta master psw
self.dialogo_master_psw = QDialog()
self.alerta_master_psw = Ui_dialogo_master_psw()
self.alerta_master_psw.setupUi(self.dialogo_master_psw)
# Botones
self.ui.boton_guardar_config.clicked.connect(self.guardar_config)
self.ui.boton_info.clicked.connect(self.cargar_info)
self.ui.boton_generar.clicked.connect(self.llamar_generar_contrasena) # Boton generar contrasñea
self.ui.boton_guardar.clicked.connect(self.guardar_contrasena) # boton guardar data
# Si presionan el boton revelar contraseña
self.ui.reveal_psw.clicked.connect(self.mostrar_contrasena)
self.alerta_master_psw.reveal_master_psw.clicked.connect(self.mostrar_contrasena_maestra)
# Icono del boton revelar contraseña
self.icon_not_view = QIcon()
self.icon_not_view.addPixmap(QPixmap(":/media/iconografia/not_view.png"), QIcon.Normal, QIcon.Off)
self.icon_view = QIcon()
self.icon_view.addPixmap(QPixmap(":/media/iconografia/view.png"), QIcon.Normal, QIcon.Off)
# Click en botones copiar # Otra manera de hacerlo: partial(self.llamar_copiar(n)) using functools.partial
self.ui.cp1.clicked.connect(lambda: self.llamar_copiar(1))
self.ui.cp2.clicked.connect(lambda: self.llamar_copiar(2))
self.ui.cp3.clicked.connect(lambda: self.llamar_copiar(3))
# Botones DB
self.ui.boton_filtro.clicked.connect(lambda: self.filtrar())
self.ui.boton_editar.clicked.connect(lambda: self.gestor_boton_editar_guardar())
self.ui.boton_seguridad.clicked.connect(lambda: self.mostrar_contrasenas())
# Botones Info
self.info_app.boton_steam.clicked.connect(lambda: backend.abrir_link("https://steamcommunity.com/id/JosephKm"))
self.info_app.boton_discord.clicked.connect(lambda: backend.abrir_link("https://discord.gg/wYuXPQS"))
self.info_app.boton_github.clicked.connect(
lambda: backend.abrir_link("https://github.com/kuttz-dev/Password-manager"))
# Si se presiona la pestaña de configuracion
# self.ui.tab_3.connect(self.cargar_config)
# SETEAR COMBOBOXES
self.ui.comboBox_usuario.setInsertPolicy(QComboBox.InsertAlphabetically)
self.ui.comboBox_mail.setInsertPolicy(QComboBox.InsertAlphabetically)
self.ui.comboBox_categoria.setInsertPolicy(QComboBox.InsertAlphabetically)
self.ui.comboBox_usuario.setDuplicatesEnabled(False)
self.ui.comboBox_mail.setDuplicatesEnabled(False)
self.ui.comboBox_categoria.setDuplicatesEnabled(False)
self.ui.comboBox_usuario.clearEditText()
self.ui.comboBox_mail.clearEditText()
self.ui.comboBox_categoria.clearEditText()
def organizar_db(self):
self.general_query.exec_(
'CREATE TABLE IF NOT EXISTS passwords (id INTEGER PRIMARY KEY ASC, categoria TEXT, icono BLOB, servicio TEXT, mail TEXT, usuario TEXT, contraseña_encriptada BLOB);'
)
self.general_query.exec_(
'CREATE TABLE IF NOT EXISTS maestra (id INTEGER PRIMARY KEY, muestra BLOB);'
)
self.general_query.exec_(
'DELETE FROM passwords WHERE usuario = "" AND mail = "" AND contraseña_encriptada = ""'
)
self.db.commit()
def borrar_columna_contrasenas(self):
self.general_query.exec_(
'DROP TABLE IF EXISTS temporal'
)
self.general_query.exec_(
'CREATE TABLE temporal (id INTEGER PRIMARY KEY ASC, categoria TEXT, icono BLOB, servicio TEXT, mail TEXT, usuario TEXT, contraseña_encriptada BLOB);'
)
self.popular.exec_(
'INSERT INTO temporal(id, categoria, icono, servicio, mail, usuario, contraseña_encriptada) SELECT id, categoria, icono, servicio, mail, usuario, contraseña_encriptada FROM passwords'
)
self.db.commit()
self.general_query.exec_(
'DROP TABLE IF EXISTS passwords'
)
self.popular.exec_(
'ALTER TABLE temporal RENAME TO passwords'
)
self.general_query.exec_(
'DROP TABLE IF EXISTS temporal'
)
self.db.commit()
def cargar_config(self):
largo, mayus, minus, numeros, special, icono = backend.obtener_cfg()
self.ui.spinBox_largo.setProperty("value", int(largo))
self.ui.check_mayus.setChecked(backend.string2bool(mayus))
self.ui.check_min.setChecked(backend.string2bool(minus))
self.ui.check_numeros.setChecked(backend.string2bool(numeros))
self.ui.check_caracteres.setChecked(backend.string2bool(special))
self.ui.check_amor.setChecked(backend.string2bool(icono))
def guardar_config(self):
hay_opcion_verdadera = False
largo = self.ui.spinBox_largo.value()
mayus = self.ui.check_mayus.checkState()
minus = self.ui.check_min.checkState()
numeros = self.ui.check_numeros.checkState()
special = self.ui.check_caracteres.checkState()
icono = self.ui.check_amor.checkState()
estado_checkeado = [mayus, minus, numeros, special, icono]
for i in range(len(estado_checkeado)):
if str(estado_checkeado[i]) == "PySide2.QtCore.Qt.CheckState.Checked":
if i != 4: # len de estado_checkeado - 1
hay_opcion_verdadera = True
estado_checkeado[i] = True
else:
estado_checkeado[i] = False
if hay_opcion_verdadera is False:
return self.alerta_config.exec()
backend.generar_cfg(largo,
estado_checkeado[0],
estado_checkeado[1],
estado_checkeado[2],
estado_checkeado[3],
estado_checkeado[4]
)
self.cargar_config()
def cargar_info(self):
return self.dialogo_info.exec()
def llamar_generar_contrasena(self):
# Primero obtenemos que tipo de contraseña quiere el usuario
largo, mayus, minus, numeros, special, icono = backend.obtener_cfg()
mayus = backend.string2bool(mayus)
minus = backend.string2bool(minus)
numeros = backend.string2bool(numeros)
special = backend.string2bool(special)
if mayus is False and minus is False and numeros is False and special is False:
self.alerta_config.exec()
texto_contrasena = backend.generar_contraseña(int(largo), mayus, minus, numeros, special)
self.ui.input_psw.setText(str(texto_contrasena)) # Ponemos la contraseña en la aplicacion
def mostrar_contrasena(self):
# Si esta en password a normal y viceversa
if self.ui.input_psw.echoMode() == QLineEdit.EchoMode.Password:
self.ui.reveal_psw.setIcon(self.icon_not_view)
self.ui.input_psw.setEchoMode(QLineEdit.Normal)
else:
self.ui.reveal_psw.setIcon(self.icon_view)
self.ui.input_psw.setEchoMode(QLineEdit.Password)
def mostrar_contrasena_maestra(self, modo_echo=False):
# Si no se cambio el estado va a estar en False y se va a usar el echoMode del input
if modo_echo is False:
modo_echo = self.alerta_master_psw.input_master_psw.echoMode()
# Si esta en password a normal y viceversa
if modo_echo == QLineEdit.EchoMode.Password:
self.alerta_master_psw.reveal_master_psw.setIcon(self.icon_not_view)
self.alerta_master_psw.input_master_psw.setEchoMode(QLineEdit.Normal)
else:
self.alerta_master_psw.reveal_master_psw.setIcon(self.icon_view)
self.alerta_master_psw.input_master_psw.setEchoMode(QLineEdit.Password)
def llamar_copiar(self, numero_boton):
if numero_boton == 1:
backend.copiar(str(self.ui.input_psw.text()))
if numero_boton == 2:
backend.copiar(str(self.ui.comboBox_usuario.currentText()))
if numero_boton == 3:
backend.copiar(str(self.ui.comboBox_mail.currentText()))
def preparar_favicon(self, url):
try:
archivo_ico = backend.descargar_favico(url)
except Exception: # Si lo que se ingreso era un link pero no se consiguio favicon
with open("media/favicons/domain.ico") as ico:
return QByteArray(ico.read())
# Si no se consiguio la imagen
if archivo_ico is None:
return None
with open(archivo_ico, "rb") as ico:
return QByteArray(ico.read())
def guardar_contrasena(self):
# self.ui.comboBox_usuario.currentText() / self.ui.comboBox_mail.currentText()
# self.ui.comboBox_categoria.currentText() / self.ui.input_url.text()
# self.ui.input_psw.text()
if self.master_key is None:
try:
self.master_key = self.pedir_contrasena_maestra()
except Exception:
return
if self.ui.input_psw.text() != "":
contrasena_ingresada_encriptada = QByteArray(pswCrypto.encriptar(self.ui.input_psw.text(), self.master_key))
else:
contrasena_ingresada_encriptada = ""
try:
fav_icon = self.preparar_favicon(self.ui.input_url.text())
self.save_query.prepare(
'INSERT INTO passwords (categoria, icono, servicio, mail, usuario, contraseña_encriptada) VALUES(?,?,?,?,?,?)'
)
self.save_query.addBindValue(self.ui.comboBox_categoria.currentText())
self.save_query.addBindValue(fav_icon)
self.save_query.addBindValue(self.ui.input_url.text())
self.save_query.addBindValue(self.ui.comboBox_mail.currentText())
self.save_query.addBindValue(self.ui.comboBox_usuario.currentText())
self.save_query.addBindValue(contrasena_ingresada_encriptada)
self.save_query.exec_()
self.db.commit()
self.model.select()
self.ui.tabla_db.resizeColumnsToContents()
self.cargar_opciones_combo_boxes()
return self.alerta_guardado_exitoso.exec()
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
print(message)
def pedir_contrasena_maestra(self):
self.dialogo_master_psw.exec()
contrasena_maestra = self.alerta_master_psw.input_master_psw.text()
# Borrarmos el texto porque no se borra solo, y lo volvemos secreto de nuevo
self.alerta_master_psw.input_master_psw.setText("")
self.mostrar_contrasena_maestra(QLineEdit.EchoMode.Normal)
# Si le dio a cancelar
if bool(self.dialogo_master_psw.result()) is False:
raise Exception("Accion canelada")
# Comprobamos que cumpla requisitos
if contrasena_maestra == "" or len(contrasena_maestra) < 6 or len(contrasena_maestra) > 16:
self.alerta_master_psw_mala.exec()
return self.pedir_contraseña_maestra()
# Encriptacion
key_contrasena_maestra = pswCrypto.generar_key(contrasena_maestra) # La convertimos en una key
# Verificacion
# Obtenemos la muestra guardada en la db
muestra_db = backend.obtener_muestra_db()
# Si no habia guardamos una nueva con esta contraseña maestra
if muestra_db is None:
array = QByteArray(backend.generar_muestra(key_contrasena_maestra))
self.master_query.prepare("INSERT INTO maestra (id, muestra) VALUES(1, ?)")
self.master_query.addBindValue(array)
self.master_query.exec_()
return key_contrasena_maestra
else:
# Ahora si verificamos
psw_correcta = backend.verificar_key(muestra_db, key_contrasena_maestra)
if psw_correcta is True:
return key_contrasena_maestra
else:
self.alerta_master_psw_incorrecta.exec_()
raise Exception("Contraseña maestra incorrecta")
def filtrar(self):
if self.ui.input_filtro.text() == "":
self.model.setFilter("")
return self.model.select()
else:
self.model.setFilter(
"{} LIKE '{}%'".format(self.ui.combobox_filtro.currentText().lower(), self.ui.input_filtro.text())
)
return self.model.select()
def mostrar_contrasenas(self):
if self.master_key is None:
try:
self.master_key = self.pedir_contrasena_maestra()
except Exception:
return
if self.candado == "abierto": # Si esta abierto
self.borrar_columna_contrasenas()
self.ui.combobox_filtro.removeItem(4)
self.organizar_tabla_ui()
self.ui.boton_seguridad.setIcon(self.icon_seguridad)
self.candado = "cerrado" # lo cerramos
return
else: # Si estaba cerrado
self.candado = "abierto" # lo abrimos
# y se abre asi:
self.ui.boton_seguridad.setIcon(self.icon_desbloqueado)
# Conseguimos las contraseñas encriptadas
self.passwords_query_retrieve.exec_('SELECT id, contraseña_encriptada FROM passwords')
# Creamos una columna para las contraseñas descifradas
self.general_query.exec_('ALTER TABLE passwords ADD contraseña TEXT')
self.db.commit()
# Para cada contraseña
while self.passwords_query_retrieve.next():
# Si se guardo un texto vacio
contrasena_descifrada = self.passwords_query_retrieve.value(1)
if type(contrasena_descifrada) != str:
contrasena_descifrada = pswCrypto.descifrar(contrasena_descifrada.data(), self.master_key)
self.passwords_query_write.prepare('UPDATE passwords SET contraseña = ? WHERE id= ?')
self.passwords_query_write.addBindValue(contrasena_descifrada)
self.passwords_query_write.addBindValue(self.passwords_query_retrieve.value(0))
self.passwords_query_write.exec_()
self.ui.combobox_filtro.addItem("Contraseña")
self.organizar_tabla_ui() # Las hacemos visibles el la tabla
def actualizar_tabs(self, index):
if index == 0:
self.resize(437, 200)
self.cargar_opciones_combo_boxes()
if index == 1 and self.ui.boton_seguridad.isEnabled() is True:
self.organizar_tabla_ui()
elif index == 2:
self.resize(437, 200)
self.cargar_config()
def organizar_tabla_ui(self):
self.model.setTable('passwords')
self.model.setSort(1, Qt.AscendingOrder)
self.model.select()
self.ui.tabla_db.setModel(self.model)
self.ui.tabla_db.setItemDelegateForColumn(2, pswItemDelegate.ImageDelegate(self.ui.tabla_db))
self.ui.tabla_db.hideColumn(0) # Escondemos id
self.ui.tabla_db.hideColumn(6) # Escondemos las contraseñas encriptadas
self.ui.tabla_db.setWindowTitle("Lista de cuentas")
# Tamaño columnas
#self.ui.tabla_db.resizeColumnsToContents()
self.ui.tabla_db.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.ui.tabla_db.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed) # iconos
self.ui.tabla_db.setColumnWidth(2, 32) # tamaño iconos
self.ui.tabla_db.verticalHeader().setVisible(False)
self.ui.tabla_db.setSortingEnabled(True)
def cargar_opciones_combo_boxes(self):
a = self.ui.comboBox_categoria.currentText()
b = self.ui.comboBox_mail.currentText()
c = self.ui.comboBox_usuario.currentText()
self.comboBoxes_query_categoria.exec_(
'SELECT DISTINCT categoria FROM passwords'
)
self.comboBoxes_query_mail.exec_(
'SELECT DISTINCT mail FROM passwords'
)
self.comboBoxes_query_usuario.exec_(
'SELECT DISTINCT usuario FROM passwords'
)
# Borramos las anteriores
self.ui.comboBox_usuario.clear()
self.ui.comboBox_mail.clear()
self.ui.comboBox_categoria.clear()
# Cargamos las nuevas
while self.comboBoxes_query_categoria.next():
if self.comboBoxes_query_categoria.value(0) == "" or self.comboBoxes_query_categoria.value(0) is None:
continue
self.ui.comboBox_categoria.addItem(self.comboBoxes_query_categoria.value(0))
while self.comboBoxes_query_mail.next():
if self.comboBoxes_query_mail.value(0) == "" or self.comboBoxes_query_mail.value(0) is None:
continue
self.ui.comboBox_mail.addItem(self.comboBoxes_query_mail.value(0))
while self.comboBoxes_query_usuario.next():
if self.comboBoxes_query_usuario.value(0) == "" or self.comboBoxes_query_usuario.value(0) is None:
continue
self.ui.comboBox_usuario.addItem(self.comboBoxes_query_usuario.value(0))
self.ui.comboBox_categoria.setCurrentText(a)
self.ui.comboBox_mail.setCurrentText(b)
self.ui.comboBox_usuario.setCurrentText(c)
def revisar_columna_contrasenas(self, borrar=True):
existe = self.verificar_columna_contrasenas.exec_('SELECT contraseña FROM passwords LIMIT 1')
if existe is True and borrar is True:
self.verificar_columna_contrasenas.finish()
self.borrar_columna_contrasenas()
return self.organizar_tabla_ui()
elif existe is True:
return "Existe"
def gestor_boton_editar_guardar(self):
if self.modo_boton_editar_guardar == "editar":
try:
self.editar_tabla_ui()
except Exception:
return
self.modo_boton_editar_guardar = "guardar" # Cambiamos al proximo modo
return self.ui.boton_editar.setIcon(self.icon_guardar)
elif self.modo_boton_editar_guardar == "guardar":
self.borrar_columna_contrasenas()
self.organizar_tabla_ui()
self.candado = "cerrado"
self.ui.boton_seguridad.setDisabled(False)
self.ui.boton_seguridad.setIcon(self.icon_seguridad)
self.ui.boton_editar.setIcon(self.icon_editar)
self.modo_boton_editar_guardar = "editar" # Cambiamos al proximo modo
return
def editar_tabla_ui(self):
if self.master_key is None:
try:
self.master_key = self.pedir_contrasena_maestra()
except Exception:
raise Exception("No se pudo conseguir master key")
self.ui.boton_seguridad.setDisabled(True)
if self.candado == "cerrado":
self.mostrar_contrasenas()
def celdas_cambiadas(self, top_left, bottom_right):
if self.modo_boton_editar_guardar == "editar":
return
else:
if top_left.column() == 7:
contrasena_editada_encriptada = ""
if self.model.record(top_left.row()).value('contraseña') != "":
contrasena_editada_encriptada = QByteArray(
pswCrypto.encriptar(self.model.record(top_left.row()).value('contraseña'), self.master_key))
casilla_editada = QSqlField("contraseña_encriptada")
casilla_editada.setValue(contrasena_editada_encriptada)
valores_fila = self.model.record(top_left.row())
valores_fila.replace(6, casilla_editada)
return self.model.updateRowInTable(top_left.row(), valores_fila)
else:
self.model.updateRowInTable(top_left.row(), self.model.record(top_left.row()))
return self.db.commit()
def borrar_linea(self, row):
self.model.deleteRowFromTable(row)
return self.model.select()
def context_menu(self):
# Menu con click derecho
if self.ui.tabla_db.selectedIndexes() and self.modo_boton_editar_guardar == "guardar":
menu = QMenu()
borrar_data = menu.addAction("Borrar linea de la base de datos")
borrar_data.triggered.connect(lambda: self.borrar_linea(self.ui.tabla_db.currentIndex().row()))
cursor = QCursor()
menu.exec_(cursor.pos())
def get_customer_record(customer_id: int) -> QSqlRecord:
model = QSqlTableModel()
model.setTable("customers")
model.setFilter(F"customer_id = '{customer_id}'")
model.select()
return model.record(0)
class AbstractOperationDetails(QWidget):
dbUpdated = Signal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.model = None
self.table_name = ''
self.mapper = None
self.modified = False
self.name = "N/A"
self.layout = QGridLayout(self)
self.layout.setContentsMargins(2, 2, 2, 2)
self.bold_font = QFont()
self.bold_font.setBold(True)
self.bold_font.setWeight(75)
self.main_label = QLabel(self)
self.main_label.setFont(self.bold_font)
self.layout.addWidget(self.main_label, 0, 0, 1, 1, Qt.AlignLeft)
self.commit_button = QPushButton(self)
self.commit_button.setEnabled(False)
self.commit_button.setText("✔")
self.commit_button.setFont(self.bold_font)
self.commit_button.setFixedWidth(
self.commit_button.fontMetrics().width("XXX"))
self.revert_button = QPushButton(self)
self.revert_button.setEnabled(False)
self.revert_button.setText("✖️")
self.revert_button.setFont(self.bold_font)
self.revert_button.setFixedWidth(
self.revert_button.fontMetrics().width("XXX"))
self.verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.horizontalSpacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
def _init_db(self, table_name):
self.table_name = table_name
self.model = QSqlTableModel(parent=self, db=db_connection())
self.model.setTable(table_name)
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.mapper = QDataWidgetMapper(self.model)
self.mapper.setModel(self.model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.AutoSubmit)
self.model.dataChanged.connect(self.onDataChange)
self.commit_button.clicked.connect(self.saveChanges)
self.revert_button.clicked.connect(self.revertChanges)
def isCustom(self):
return True
def setId(self, id):
self.model.setFilter(f"id={id}")
self.mapper.setCurrentModelIndex(self.model.index(0, 0))
@Slot()
def onDataChange(self, _index_start, _index_stop, _role):
self.modified = True
self.commit_button.setEnabled(True)
self.revert_button.setEnabled(True)
@Slot()
def saveChanges(self):
if not self.model.submitAll():
logging.fatal(
g_tr('AbstractOperationDetails', "Operation submit failed: ") +
self.model.lastError().text())
return False
self.modified = False
self.commit_button.setEnabled(False)
self.revert_button.setEnabled(False)
self.dbUpdated.emit()
return True
@Slot()
def revertChanges(self):
self.model.revertAll()
self.modified = False
self.commit_button.setEnabled(False)
self.revert_button.setEnabled(False)
def createNew(self, account_id=0):
self.mapper.submit(
) # FIXME there is check for uncommited call before - do we need submit() here?
self.model.setFilter(f"{self.table_name}.id = 0")
new_record = self.prepareNew(account_id)
assert self.model.insertRows(0, 1)
self.model.setRecord(0, new_record)
self.mapper.toLast()
def prepareNew(self, account_id):
new_record = self.model.record()
return new_record
def copyNew(self):
row = self.mapper.currentIndex()
new_record = self.copyToNew(row)
self.model.setFilter(f"{self.table_name}.id = 0")
assert self.model.insertRows(0, 1)
self.model.setRecord(0, new_record)
self.mapper.toLast()
def copyToNew(self, row):
new_record = self.model.record(row)
return new_record
def new_settings(parent):
m_id = p1_id = p2_id = set = leg = 0
var = ""
# manage_settings_window = GameSettingsDialog()
# manage_settings_window.show()
if manage_settings_window.exec_():
player1 = manage_settings_window.input_player1_name.text()
player2 = manage_settings_window.input_player2_name.text()
# A MATCH_ID-T AZ AUTOINCREMENTBŐL KELLENE VISSZAKÉRNI ÉS NEM IMPLICIT RANDOMBÓL GENERÁLNI
m_id = random.randint(10, 1000000)
# print(m_id)
set = manage_settings_window.spin_legs.value()
leg = manage_settings_window.spin_sets.value()
if manage_settings_window.gomb_301.isChecked():
var = "301"
elif manage_settings_window.gomb_401.isChecked():
var = "401"
elif manage_settings_window.gomb_501.isChecked():
var = "501"
else:
var = "701"
# print(var)
player1_id_model = QSqlQueryModel()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}'",
db=db)
player1_id_model.setQuery(query1)
if player1_id_model.record(0).value(0):
p1_id = int(player1_id_model.record(0).value(0))
else:
player_model1 = QSqlTableModel()
player_model1.setTable("players")
rec_play1 = player_model1.record()
rec_play1.remove(0)
rec_play1.setValue(0, player1)
if player_model1.insertRecord(-1, rec_play1):
player_model1.submitAll()
else:
db.rollback()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}'",
db=db)
player1_id_model.setQuery(query1)
p1_id = int(player1_id_model.record(0).value(0))
player2_id_model = QSqlQueryModel()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}'",
db=db)
player2_id_model.setQuery(query2)
if player2_id_model.record(0).value(0):
p2_id = int(player2_id_model.record(0).value(0))
else:
player_model2 = QSqlTableModel()
player_model2.setTable("players")
rec_play2 = player_model2.record()
rec_play2.remove(0)
rec_play2.setValue(0, player2)
if player_model2.insertRecord(-1, rec_play2):
player_model2.submitAll()
else:
db.rollback()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}'",
db=db)
player2_id_model.setQuery(query2)
p2_id = int(player2_id_model.record(0).value(0))
# Match paremeterek rögzítése
match_model = QSqlTableModel()
match_model.setTable("match_settings")
record = match_model.record()
record.setValue(0, m_id)
record.setValue(1, p1_id)
record.setValue(2, p2_id)
record.setValue(3, var)
record.setValue(4, set)
record.setValue(5, leg)
if match_model.insertRecord(-1, record):
match_model.submitAll()
else:
db.rollback()
# parent.main_layout.addLayout(parent.match_layout)
# parent.match_layout.addWidget(parent.cimke)
# parent.main_layout.addWidget(parent.GameWindow)
parent.gomb1.setText("OK")
else:
# parent.gomb1.setText("Cancel")
parent.close()
def insert_torna_settings(self):
van_ilyen_nev = False
if len(self.torna_name.text()) != 0:
torna_id_model = QSqlQueryModel()
query = QSqlQuery(
"select torna_id, torna_name from torna_settings", db=db)
torna_id_model.setQuery(query)
for i in range(torna_id_model.rowCount()):
if torna_id_model.record(i).value(1) == self.torna_name.text():
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Név ütközés!")
msg.setText(
'<html style="font-size: 14px; color: red">Már van ilyen nevű verseny!<br></html>'
+
'<html style="font-size: 16px">Kérem adjon a versenynek egyedi nevet!</html>'
)
msg.exec_()
van_ilyen_nev = True
if not van_ilyen_nev:
torna_settings_model = QSqlTableModel(
db=db
) # !!!!!!! Ha több db van, akkor itt konkrétan meg kell adni
torna_settings_model.setTable("torna_settings")
record = torna_settings_model.record()
record.setValue(1, self.torna_name.text())
if self.is_roundrobin.isChecked():
record.setValue(2, 1)
else:
record.setValue(2, 0)
record.setValue(3, self.csoport_number.value())
record.setValue(4, self.jatekos_per_csoport.value())
record.setValue(5, self.variant.value())
if self.is_sets.isChecked():
record.setValue(6, 1)
else:
record.setValue(6, 0)
record.setValue(7, self.sets_number.value())
record.setValue(8, self.legs_number.value())
# print(record.value(2))
if self.is_best.isChecked():
record.setValue(9, 1)
else:
record.setValue(9, 0)
if self.is_draw.isChecked():
record.setValue(10, 1)
else:
record.setValue(10, 0)
record.setValue(11, self.pont_win.value())
record.setValue(12, self.pont_draw.value())
record.setValue(13, self.pont_lost.value())
if self.is_single_elim.isChecked():
record.setValue(14, 1)
else:
record.setValue(14, 0)
record.setValue(15, self.num_single.value())
if self.is_3place.isChecked():
record.setValue(16, 1)
else:
record.setValue(16, 0)
record.setValue(17, self.leg_num_single.value())
record.setValue(18, self.leg_num_semifinal.value())
record.setValue(19, self.leg_num_3place.value())
record.setValue(20, self.leg_num_final.value())
record.setValue(21, 2)
# aktiv flag: 0: vége, 1: folyamatban, 2: szerkesztés alatt
# print(record)
if torna_settings_model.insertRecord(-1, record):
torna_settings_model.submitAll()
else:
db.rollback()
torna_id_model2 = QSqlQueryModel()
query2 = QSqlQuery(
f"select torna_id from torna_settings where torna_name='{self.torna_name.text()}'",
db=db)
torna_id_model2.setQuery(query2)
self.torna_id = int(torna_id_model2.record(0).value(0))
self.gomb_members.setDisabled(False)
else:
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Hiányzik a verseny neve!")
msg.setText(
'<html style="font-size: 14px; color: red">A létrehozott versenynek kell egy elnevezés!<br></html>'
+
'<html style="font-size: 16px">Kérem adja meg a verseny nevét!</html>'
)
msg.exec_()
def alapertekek(self):
if not self.torna_id:
self.torna_name.clear()
self.is_roundrobin.setChecked(True)
self.csoport_number.setValue(1)
self.jatekos_per_csoport.setValue(4)
self.variant.setValue(501)
self.is_sets.setChecked(False)
self.sets_number.setValue(1)
self.legs_number.setValue(2)
self.is_best.setChecked(False)
self.is_draw.setChecked(False)
self.pont_win.setValue(2)
self.pont_draw.setValue(1)
self.pont_lost.setValue(0)
self.is_single_elim.setChecked(False)
self.num_single.setValue(8)
self.leg_num_single.setValue(3)
self.leg_num_semifinal.setValue(4)
self.leg_num_final.setValue(5)
self.is_3place.setChecked(False)
self.leg_num_3place.setValue(4)
else:
model = QSqlTableModel(db=db)
model.setTable("torna_settings")
model.setFilter(f"torna_id={self.torna_id}")
model.select()
# print(model.record(0))
self.torna_name.setText(model.record(0).value(1))
self.is_roundrobin.setChecked(model.record(0).value(2))
self.csoport_number.setValue(model.record(0).value(3))
self.jatekos_per_csoport.setValue(model.record(0).value(4))
self.variant.setValue(int(model.record(0).value(5)))
self.is_sets.setChecked(model.record(0).value(6))
self.sets_number.setValue(model.record(0).value(7))
self.legs_number.setValue(model.record(0).value(8))
self.is_best.setChecked(model.record(0).value(9))
self.is_draw.setChecked(model.record(0).value(10))
self.pont_win.setValue(model.record(0).value(11))
self.pont_draw.setValue(model.record(0).value(12))
self.pont_lost.setValue(model.record(0).value(13))
self.is_single_elim.setChecked(model.record(0).value(14))
self.num_single.setValue(model.record(0).value(15))
self.leg_num_single.setValue(model.record(0).value(17))
self.leg_num_semifinal.setValue(model.record(0).value(18))
self.leg_num_final.setValue(model.record(0).value(20))
self.is_3place.setChecked(model.record(0).value(16))
self.leg_num_3place.setValue(model.record(0).value(19))
class ManageMembers(QMainWindow):
def __init__(self, parent):
super(ManageMembers, self).__init__(parent)
self.setWindowTitle("Tagok kezelése")
widget = QWidget()
main_layout = QHBoxLayout()
widget.setLayout(main_layout)
self.setCentralWidget(widget)
self.table_view = QTableView()
main_layout.addWidget(self.table_view)
self.model = QSqlTableModel(db=db)
self.model.setTable("members")
self.model.select()
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.model.setHeaderData(1, Qt.Horizontal, "Vezetéknév")
self.model.setHeaderData(2, Qt.Horizontal, "Utónév")
self.model.setHeaderData(3, Qt.Horizontal, "Született")
self.model.setHeaderData(4, Qt.Horizontal, "Ir.szám")
self.model.setHeaderData(5, Qt.Horizontal, "Helység")
self.model.setHeaderData(6, Qt.Horizontal, "Cím")
self.model.setHeaderData(7, Qt.Horizontal, "Telefon")
self.model.setHeaderData(8, Qt.Horizontal, "E-mail")
self.model.setHeaderData(9, Qt.Horizontal, "Tagság kezdete")
self.model.setHeaderData(10, Qt.Horizontal, "Aktív")
# self.model.setFilter('vezeteknev Like "Czi%"')
self.table_view.setModel(self.model)
self.table_view.hideColumn(0)
self.table_view.resizeColumnsToContents()
# Ha ez engedélyezve, akkor a model-nél beállított sort nem működik, ez felülírja
# Enélkül működik a model-es beállítás
self.table_view.setSortingEnabled(True)
# Ha engedélyezve van a fejléc szerinti rendezés, akkor UTÁNA meg lehet adni az alap sorrendet
self.table_view.sortByColumn(1, Qt.AscendingOrder)
self.model.dataChanged.connect(self.valtozott)
gomb_layout = QVBoxLayout()
main_layout.addLayout(gomb_layout)
self.delete_button = QPushButton("&Tag törlése")
self.add_button = QPushButton("&Új tag")
self.apply_button = QPushButton("Módosítások alkalmazása")
self.cancel_button = QPushButton("Módosítások elvetése")
gomb_layout.addWidget(self.delete_button)
gomb_layout.addWidget(self.add_button)
gomb_layout.addWidget(self.apply_button)
gomb_layout.addWidget(self.cancel_button)
self.space = QSpacerItem(0, 0, QSizePolicy.Minimum,
QSizePolicy.Expanding)
gomb_layout.addItem(self.space)
self.setFixedSize(1000, 800)
tb = self.addToolBar("File")
exit = QAction(QIcon("images/door--arrow.png"), "Kilépés", self)
tb.addAction(exit)
excel = QAction(QIcon("images/excel.png"), "Excel", self)
tb.addAction(excel)
tb.actionTriggered[QAction].connect(self.toolbarpressed)
self.delete_button.clicked.connect(self.tag_torles)
self.add_button.clicked.connect(self.tag_hozzadas)
self.apply_button.clicked.connect(self.valtozas_mentese)
self.cancel_button.clicked.connect(self.valtozas_elvetese)
def tag_hozzadas(self):
self.form_window = UjtagFormDialog()
self.form_window.setWindowTitle("Új tag felvétele")
if self.form_window.exec_():
record = self.model.record()
record.remove(record.indexOf('id'))
for i in range(len(self.form_window.mezo_ertekek)):
record.setValue(i, self.form_window.mezo_ertekek[i].text())
# print(i, record.value(i))
if self.model.insertRecord(-1, record):
self.model.submitAll()
self.apply_button.setStyleSheet('')
self.cancel_button.setStyleSheet('')
else:
db.rollback()
def tag_torles(self):
if len(self.table_view.selectedIndexes()) > 0:
self.model.removeRow(self.table_view.selectedIndexes()[0].row())
self.model.submitAll()
else:
reply = QMessageBox.question(None, 'Hiba!',
'Törlés előtt jelöljön ki egy sort!',
QMessageBox.Ok)
def toolbarpressed(self, a):
if a.text() == "Kilépés":
self.close()
if a.text() == "Excel":
data = []
for i in range(self.model.rowCount()):
sor = []
for j in range(self.model.columnCount()):
if isinstance(self.model.record(i).value(j), QDate):
sor.append(
self.model.record(i).value(j).toString(
"yyyy-MM-dd"))
else:
sor.append(self.model.record(i).value(j))
data.append(sor)
p.save_as(array=data, dest_file_name="tagok.xlsx")
def valtozott(self):
self.apply_button.setStyleSheet('background-color: green;')
self.cancel_button.setStyleSheet('background-color: red;')
def valtozas_mentese(self):
self.model.submitAll()
self.apply_button.setStyleSheet('')
self.cancel_button.setStyleSheet('')
def valtozas_elvetese(self):
self.model.revertAll()
self.apply_button.setStyleSheet('')
self.cancel_button.setStyleSheet('')
