def doLogin(self, username, password):
query = QSqlQuery()
query.prepare("select id from qtapp_users where username = :username and password = :password")
query.bindValue(":username", username)
query.bindValue(":password", helper.computeHash(password))
query.exec_()
if query.next():
return True
return False
def preSupprVerification(self, index):
u"""Vérification à effectuer avant d'autoriser à supprimer un item
Renvoit False si la suppression est interdite
"""
sql = """
SELECT COUNT(*)
FROM absence
WHERE id_intervenant=""" + str(index.sibling(index.row(), 0).data())
req = QSqlQuery()
if req.exec_(sql):
req.next()
nbAbsences = req.record().value(0)
if nbAbsences != 0:
pl = ""
if nbAbsences != 1:
pl = "s"
QMessageBox.critical(
self, "Impossible de suppprimer",
u"L'intervenant a encore " + str(nbAbsences) +
u" absence" + pl + u" enregistrée" + pl + "<br />" +
u"Il faut les supprimer avant")
# TODO trouver un moyen de setter l'onglet de l'application
# self._ui.tabWidget.setCurrentIndex(1)
return False
# TODO gérer le else, au moins logger quelque chose
return True
def preSupprVerification(self, index):
u"""Vérification à effectuer avant d'autoriser à supprimer un item
Renvoit False si la suppression est interdite
"""
sql = """
SELECT COUNT(*)
FROM absence
WHERE id_intervenant=""" + str(index.sibling(index.row(), 0).data())
req = QSqlQuery()
if req.exec_(sql):
req.next()
nbAbsences = req.record().value(0)
if nbAbsences != 0:
pl = ""
if nbAbsences != 1:
pl = "s"
QMessageBox.critical(self, "Impossible de suppprimer",
u"L'intervenant a encore " + str(nbAbsences) +
u" absence" + pl + u" enregistrée" + pl + "<br />" +
u"Il faut les supprimer avant")
# TODO trouver un moyen de setter l'onglet de l'application
# self._ui.tabWidget.setCurrentIndex(1)
return False
# TODO gérer le else, au moins logger quelque chose
return True
def load(layout):
""""Loads the file and restores the saved state"""
# Restore the first day of usage
global_vars.DAYFIRST = datetime.date.fromordinal(int(open(paths.savePath).read().splitlines()[0]))
filename = os.path.basename(paths.savePath)[:-8]
database.setConnection(filename)
layout.initTasks(database.getStatuses())
layout.tab.clearAll()
# ### Loading main table
#
#
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
opened = False
q = 'SELECT * FROM main'
query = QSqlQuery(q)
while query.next():
record = query.record()
indexes = []
if not record.isEmpty():
for i in range(0, 44):
if not record.isNull(i + 1):
indexes.append(i)
day = str(record.field('weekday').value()).split('_')
weekday = day[0]
weeknum = int(day[1])
values = {}
for index in indexes:
q = QSqlQuery("SELECT name FROM tasks WHERE rowid ='" + str(query.value(index + 1)) + "'")
q.next()
values[index] = q.value(0)
if values:
opened = True
layout.tab.setValues(values, weekdays.index(weekday), weeknum)
if not opened:
layout.tab.openTab(1)
#
#
################
# Loading evaluation values
#
q = 'SELECT * from evaluation'
query = QSqlQuery(q)
while query.next():
record = query.record()
if not record.isEmpty():
week = record.field('week').value()
values = []
for day in global_vars.WEEKDAYS:
values.append(record.field(day).value())
global_vars.EVAL_VALUES[week] = values
database.dropConnection()
def miseAJour(self):
u"""Liste les absences pouvant donner lieu à un email de rappel"""
self._ui.cbAbsence.clear()
# Vérification des mails à envoyer
req = QSqlQuery()
sql = MailSQL.construitRequeteComptage(self.__conf["duree"])
if req.exec_(sql):
req.next()
nbMails = req.record().value(0)
else:
# TODO log
print req.lastError().text()
print req.lastQuery()
print "Erreur de requête"
return
label = str(nbMails) + " absence"
if nbMails == 0:
label += " :"
self._ui.lAbsence.setText(label)
self._ui.leSujet.setText("")
self._ui.teCorps.setText("")
self.__activerUi(False)
self._ui.pbEnvoyer.setText("Envoyer")
return
else:
self.__activerUi(True)
if nbMails > 1:
label += "s"
label += " :"
self._ui.lAbsence.setText(label)
sql = MailSQL.construitRequeteListe(self.__conf["duree"])
if not req.exec_(sql):
print req.lastError().text()
print req.lastQuery()
print "Erreur de requête"
else:
self.__absences = []
while (req.next()):
absence = {}
rec = req.record()
absence = {}
absence["id"] = rec.value(0)
absence["date"] = QDate.fromString(rec.value(1), Qt.ISODate)
absence["nom"] = rec.value(2)
absence["adresse"] = rec.value(3)
self.__absences.append(absence)
item = absence["nom"] + " le "
item += absence["date"].toString(Qt.SystemLocaleLongDate)
self._ui.cbAbsence.addItem(item)
def miseAJour(self):
u"""Liste les absences pouvant donner lieu à un email de rappel"""
self._ui.cbAbsence.clear()
# Vérification des mails à envoyer
req = QSqlQuery()
sql = MailSQL.construitRequeteComptage(self.__conf["duree"])
if req.exec_(sql):
req.next()
nbMails = req.record().value(0)
else:
# TODO log
print req.lastError().text()
print req.lastQuery()
print "Erreur de requête"
return
label = str(nbMails) + " absence"
if nbMails == 0:
label += " :"
self._ui.lAbsence.setText(label)
self._ui.leSujet.setText("")
self._ui.teCorps.setText("")
self.__activerUi(False)
self._ui.pbEnvoyer.setText("Envoyer")
return
else:
self.__activerUi(True)
if nbMails > 1:
label += "s"
label += " :"
self._ui.lAbsence.setText(label)
sql = MailSQL.construitRequeteListe(self.__conf["duree"])
if not req.exec_(sql):
print req.lastError().text()
print req.lastQuery()
print "Erreur de requête"
else:
self.__absences = []
while (req.next()):
absence = {}
rec = req.record()
absence = {}
absence["id"] = rec.value(0)
absence["date"] = QDate.fromString(rec.value(1), Qt.ISODate)
absence["nom"] = rec.value(2)
absence["adresse"] = rec.value(3)
self.__absences.append(absence)
item = absence["nom"] + " le "
item += absence["date"].toString(Qt.SystemLocaleLongDate)
self._ui.cbAbsence.addItem(item)
def getReplaysInfos(self):
#general stats
self.parent.db.open()
self.replayInfo["game_end"] = time.time()
query = QSqlQuery(self.parent.db)
queryStr = ("SELECT game_featuredMods.gamemod, gameType, filename, gameName, host, login, playerId, AI, team FROM `game_stats` LEFT JOIN game_player_stats ON `game_player_stats`.`gameId` = game_stats.id LEFT JOIN table_map ON `game_stats`.`mapId` = table_map.id LEFT JOIN login ON login.id = `game_player_stats`.`playerId` LEFT JOIN game_featuredMods ON `game_stats`.`gameMod` = game_featuredMods.id WHERE game_stats.id = %i" % self.uid)
query.exec_(queryStr)
if query.size() != 0:
self.replayInfo["num_players"] = query.size()
query.first()
self.replayInfo["featured_mod"] = str(query.value(0))
self.replayInfo["game_type"] = int(query.value(1) or 0)
mapname = str(query.value(2))
self.replayInfo["title"] = str(query.value(3).encode('utf-8'))
self.replayInfo["featured_mod_versions"] = {}
# checking featured mod version
tableMod = "updates_" + str(query.value(0))
tableModFiles = tableMod + "_files"
query2 = QSqlQuery(self.parent.db)
query2.prepare("SELECT fileId, MAX(version) FROM `%s` LEFT JOIN %s ON `fileId` = %s.id GROUP BY fileId" % (tableModFiles, tableMod, tableMod))
query2.exec_()
if query2.size() != 0 :
while query2.next() :
self.replayInfo["featured_mod_versions"][int(query2.value(0))] = int(query2.value(1))
self.replayInfo["mapname"] = os.path.splitext(os.path.basename(mapname))[0]
self.replayInfo["complete"] = True
teams = {}
while query.next() :
team = int(query.value(8))
name = str(query.value(5))
isAi = int(query.value(7))
if int(query.value(4)) == int(query.value(6)) :
self.replayInfo["host"] = name
if isAi == 0 :
if not team in teams :
teams[team] = []
teams[team].append(name)
self.replayInfo["teams"] = teams
self.parent.db.close()
def check_barcode(self, txt):
if len(txt) == self.edBarcode.maxLength():
db = Db_Instance("obook_barcode_search").get_instance()
try:
if db.open():
query = QSqlQuery(db)
query.prepare("SELECT * FROM book WHERE barcode = :barcode")
query.bindValue(":barcode", txt)
query.exec_()
if query.next():
self.add_book_from_record(query.record())
self.edBarcode.clear()
else:
raise RecordNotFoundException
else:
raise DbUnavailableException
except RecordNotFoundException:
message = unicode("Código de barra inválido!\n\n"""
"O código informado não corresponde a nenhum livro cadastrado".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Livraria", message)
except DbUnavailableException:
self.log.error(db.lastError().text())
message = unicode("Erro de conexão\n\n""Banco de dados indisponível".decode('utf-8'))
QMessageBox.critical(self, "Seareiros - Livraria", message)
self.edBarcode.setFocus()
def update(self):
query = QSqlQuery(self.parent.db)
query.prepare("SELECT id, uid_player, uid_planet, attack_time, faction, defended, IFNULL(dominant,-1) FROM `attacks` LEFT JOIN accounts ON accounts.uid = uid_player LEFT JOIN domination on faction = domination.slave WHERE 1")
query.exec_()
if query.size() > 0 :
allUids = []
while query.next() :
uid = int(query.value(0))
playeruid = int(query.value(1))
planetuid = int(query.value(2))
attack = (time.time() - query.value(3).toTime_t())
faction = int(query.value(4))
if int(query.value(6)) != -1:
faction = int(query.value(6))
defended = bool(query.value(5))
allUids.append(uid)
if not uid in self.attacks :
self.addAttack(uid, playeruid, faction, planetuid, attack, defended)
else :
self.updateAttack(uid, playeruid, attack, defended)
toDelete = []
for uid in self.attacks :
if not uid in allUids :
toDelete.append(uid)
for uid in toDelete :
del self.attacks[uid]
else :
self.attacks = {}
def getPopularLadderMaps(self, count):
query = QSqlQuery()
query.prepare("SELECT `idMap` FROM `ladder_map_selection` GROUP BY `idMap` ORDER BY count(`idUser`) DESC LIMIT %i" % count)
query.exec_()
maps = []
if query.size() > 0:
while query.next():
maps.append(int(query.value(0)))
return maps
def getSelectedLadderMaps(self, playerId):
query = QSqlQuery(self.db)
query.prepare("SELECT idMap FROM ladder_map_selection WHERE idUser = ?")
query.addBindValue(playerId)
query.exec_()
maps = []
if query.size() > 0:
while query.next():
maps.append(int(query.value(0)))
return maps
def getSelectedLadderMaps(self, playerId):
query = QSqlQuery(self.db)
query.prepare(
"SELECT idMap FROM ladder_map_selection WHERE idUser = ?")
query.addBindValue(playerId)
query.exec_()
maps = []
if query.size() > 0:
while query.next():
maps.append(int(query.value(0)))
return maps
def getPopularLadderMaps(self, count):
query = QSqlQuery()
query.prepare(
"SELECT `idMap` FROM `ladder_map_selection` GROUP BY `idMap` ORDER BY count(`idUser`) DESC LIMIT %i"
% count)
query.exec_()
maps = []
if query.size() > 0:
while query.next():
maps.append(int(query.value(0)))
return maps
def get_added_record(self):
db = Db_Instance("added_book_record").get_instance()
if db.open() and self._book_id:
query = QSqlQuery(db)
query.prepare("SELECT * FROM book WHERE id = :id")
query.bindValue(":id", self._book_id)
query.exec_()
if query.next():
return query.record()
else:
return None
else:
return None
def _get_id_from_name(self, table, name):
db = Db_Instance(table + "_fetch_" + name + "_id").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT id FROM %s WHERE name = :name" % table)
query.bindValue(":name", name)
query.exec_()
if query.next():
return query.record().value("id")
else:
return None
def _get_name_from_id(self, table, id):
db = Db_Instance(table + "_fetch_" + str(id) + "_name").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT name FROM %s WHERE id = :id" % table)
query.bindValue(":name", id)
query.exec_()
if query.next():
return query.record().value("name")
else:
return None
def get_added_record(self):
""" My workaround to get the last inserted id without any postgres specific queries """
db = Db_Instance("add_associate_last_id").get_instance()
if not db.open():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT * FROM associate WHERE fullname = :fullname")
query.bindValue(":fullname", self.edFullName.text())
query.exec_()
if query.next():
return query.record()
else:
return None
def last_id_from_sequence(table, db, id_field="id"):
# db has to be passed as parameter as we have to capture the same session for this to work
if not db.isOpen():
return None
else:
query = QSqlQuery(db)
query.prepare("SELECT currval(pg_get_serial_sequence(:table,:id))")
query.bindValue(":table", table)
query.bindValue(":id", id_field)
query.exec_()
if query.next():
return query.record().value("currval")
else:
return None
def update(self):
'''Updating depots'''
self.depots = {}
query = QSqlQuery(self.parent.db)
query.prepare("SELECT planetuid, influence, reinforcements, money FROM `planets_depots` WHERE 1")
query.exec_()
if query.size() > 0 :
while query.next():
uid = int(query.value(0))
influence = int(query.value(1))
reinforcements = int(query.value(2))
money = int(query.value(3))
if not uid in self.depots:
self.depots[uid] = Depot(uid, influence, reinforcements, money, self)
def update(self):
self.defenses = {}
query = QSqlQuery(self.parent.db)
query.prepare("SELECT planetuid, itemuid, amount, description, structure FROM planets_defense LEFT JOIN static_defenses ON static_defenses.id=planets_defense.itemuid WHERE amount != 0")
if not query.exec_():
self.log.warning(query.lastError())
if query.size() > 0 :
#query.first()
while query.next() :
planetuid = int(query.value(0))
itemuid = int(query.value(1))
amount = int(query.value(2))
description = str(query.value(3))
structure = str(query.value(4))
if not planetuid in self.defenses:
self.defenses[planetuid] = defense(planetuid, self.parent)
self.defenses[planetuid].addDefense(itemuid, amount, description, structure)
def slot_exec(self, query, params):
records = []
sql = QSqlQuery(self.db)
sql.prepare(query)
if params:
for p in params:
self.set_value(sql, p)
sql.exec_()
# number of rows returned from query execution
self.numRows.emit(sql.size())
while sql.next():
records.append(sql.record())
#sleep(1)
# row read
self.readRow.emit()
self.result.emit(records, '')
self.cleanup.emit(self.db.connectionName())
def update(self):
query = QSqlQuery(self.parent.db)
query.prepare(
"SELECT id, uid_player, uid_planet, attack_time, faction, defended, IFNULL(dominant,-1) FROM `attacks` LEFT JOIN accounts ON accounts.uid = uid_player LEFT JOIN domination on faction = domination.slave WHERE 1"
)
query.exec_()
if query.size() > 0:
allUids = []
while query.next():
uid = int(query.value(0))
playeruid = int(query.value(1))
planetuid = int(query.value(2))
attack = (time.time() - query.value(3).toTime_t())
faction = int(query.value(4))
if int(query.value(6)) != -1:
faction = int(query.value(6))
defended = bool(query.value(5))
allUids.append(uid)
if not uid in self.attacks:
self.addAttack(uid, playeruid, faction, planetuid, attack,
defended)
else:
self.updateAttack(uid, playeruid, attack, defended)
toDelete = []
for uid in self.attacks:
if not uid in allUids:
toDelete.append(uid)
for uid in toDelete:
del self.attacks[uid]
else:
self.attacks = {}
def getGWReplaysInfos(self):
self.parent.db.open()
self.replayInfo["game_end"] = time.time()
query = QSqlQuery(self.parent.db)
self.replayInfo["featured_mod"] = "gw"
self.replayInfo["game_type"] = 0
query.prepare("SELECT filename, planets.name, avatars.name \
FROM galacticwar.game_stats \
LEFT JOIN galacticwar.game_player_stats ON galacticwar.game_player_stats.`gameId` = galacticwar.game_stats.id \
LEFT JOIN galacticwar.planets ON galacticwar.planets.id = galacticwar.game_stats.planetuid \
LEFT JOIN galacticwar.planet_maps ON galacticwar.planet_maps.planetuid = galacticwar.game_stats.planetuid \
LEFT JOIN faf_lobby.table_map ON galacticwar.planet_maps.`mapuid` = faf_lobby.table_map.id \
LEFT JOIN galacticwar.avatars ON galacticwar.avatars.id = galacticwar.game_player_stats.`avatarId` \
WHERE galacticwar.game_stats.id = ? ")
query.addBindValue(self.uid)
query.exec_()
if query.size() != 0:
self.replayInfo["num_players"] = query.size()
query.first()
mapname = str(query.value(0))
self.replayInfo["title"] = str("battle on " +query.value(1))
self.replayInfo["featured_mod_versions"] = {}
tableMod = "updates_gw"
tableModFiles = tableMod + "_files"
query2 = QSqlQuery(self.parent.db)
query2.prepare("SELECT fileId, MAX(version) FROM `%s` LEFT JOIN %s ON `fileId` = %s.id GROUP BY fileId" % (tableModFiles, tableMod, tableMod))
query2.exec_()
if query2.size() != 0 :
while query2.next() :
self.replayInfo["featured_mod_versions"][int(query2.value(0))] = int(query2.value(1))
self.replayInfo["mapname"] = os.path.splitext(os.path.basename(mapname))[0]
self.replayInfo["complete"] = True
self.parent.db.close()
def save(layout):
""""Saves the state of the program and moves the save file to specified place"""
# Create a file if there is no previous save
# else move db to current folder to save
if not os.path.isfile(paths.savePath):
# Create txt and write down the first day of usage
savefile = open(paths.savePath, mode='w')
savefile.write(str(global_vars.DAYFIRST.toordinal()))
savefile.close()
filename = os.path.basename(paths.savePath)[:-8]
# Saving tasks widget block
database.setConnection(filename)
database.truncate()
groups = layout.taskwidget.getGroups()
for group in groups:
query = QSqlQuery()
query.prepare("INSERT INTO status (name) VALUES (:name)")
query.bindValue(":name", group.getName())
query.exec_()
query = QSqlQuery("SELECT rowid FROM status WHERE name = '" + group.getName() + "' ")
query.next()
id_ = query.value(0)
for task in group:
query = QSqlQuery()
query.prepare("INSERT INTO tasks (name, status) VALUES (:name, :id)")
query.bindValue(":name", task.getTask())
query.bindValue(":id", id_)
query.exec_()
# Saving maintable
for weeknum in layout.tab.notsaved:
table = layout.tab.getWidgetFromWeeknum(weeknum)
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
for weekday in weekdays:
tasks = table.getTasks(weekday)
if tasks:
fields = ''
values = ''
for time in tasks:
query = QSqlQuery("SELECT rowid FROM tasks WHERE name ='" + tasks[time] + "'")
query.next()
tasks[time] = query.value(0)
fields += '"' + time + '"' + ','
values += str(tasks[time]) + ','
fields = 'weekday,' + fields[:-1]
values = '"' + weekday + '_' + str(weeknum) + '"' + ', ' + values[:-1]
request = 'INSERT INTO main (' + fields + ') VALUES (' + values + ')'
query = QSqlQuery()
query.exec_(request)
layout.tab.notsaved = []
# Saving evaluation values
for week in global_vars.EVAL_VALUES.keys():
val = str(week) + ', '
for value in global_vars.EVAL_VALUES[week]:
val += str(value) + ', '
request = 'INSERT INTO evaluation VALUES(' + val[:-2] + ')'
query = QSqlQuery()
query.exec_(request)
# Saving neural network weights
parent = layout.parentWidget()
exists = True
try:
parent.network
except (AttributeError, NameError):
exists = False
if exists:
hdw = parent.network.hiddenweights
otpw = parent.network.outputweights
request = 'INSERT INTO weights (input, output, value) '
for i in range(len(hdw)):
for j in range(len(hdw[i])):
if (i == 0) and (j == 0):
request += 'SELECT ' + '"in_' + str(i) + '", "hidden_' + str(j) + '", ' + str(hdw[i][j])
else:
request += ' UNION ALL'
request += ' SELECT ' + '"in_' + str(i) + '", "hidden_' + str(j) + '", ' + str(hdw[i][j])
for i in range(len(otpw)):
for j in range(len(otpw[i])):
request += ' UNION ALL'
request += ' SELECT ' + '"hidden_' + str(i) + '", "out_' + str(j) + '", ' + str(hdw[i][j])
print(request)
query = QSqlQuery()
query.exec_(request)
print(query.lastError())
print('Saved')
# Restoring the original state
database.dropConnection()
def load(layout):
""""Loads the file and restores the saved state"""
# Restore the first day of usage
global_vars.DAYFIRST = datetime.date.fromordinal(
int(open(paths.savePath).read().splitlines()[0]))
filename = os.path.basename(paths.savePath)[:-8]
database.setConnection(filename)
layout.initTasks(database.getStatuses())
layout.tab.clearAll()
# ### Loading main table
#
#
weekdays = [
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
'Sunday'
]
opened = False
q = 'SELECT * FROM main'
query = QSqlQuery(q)
while query.next():
record = query.record()
indexes = []
if not record.isEmpty():
for i in range(0, 44):
if not record.isNull(i + 1):
indexes.append(i)
day = str(record.field('weekday').value()).split('_')
weekday = day[0]
weeknum = int(day[1])
values = {}
for index in indexes:
q = QSqlQuery("SELECT name FROM tasks WHERE rowid ='" +
str(query.value(index + 1)) + "'")
q.next()
values[index] = q.value(0)
if values:
opened = True
layout.tab.setValues(values, weekdays.index(weekday), weeknum)
if not opened:
layout.tab.openTab(1)
#
#
################
# Loading evaluation values
#
q = 'SELECT * from evaluation'
query = QSqlQuery(q)
while query.next():
record = query.record()
if not record.isEmpty():
week = record.field('week').value()
values = []
for day in global_vars.WEEKDAYS:
values.append(record.field(day).value())
global_vars.EVAL_VALUES[week] = values
database.dropConnection()
def save(layout):
""""Saves the state of the program and moves the save file to specified place"""
# Create a file if there is no previous save
# else move db to current folder to save
if not os.path.isfile(paths.savePath):
# Create txt and write down the first day of usage
savefile = open(paths.savePath, mode='w')
savefile.write(str(global_vars.DAYFIRST.toordinal()))
savefile.close()
filename = os.path.basename(paths.savePath)[:-8]
# Saving tasks widget block
database.setConnection(filename)
database.truncate()
groups = layout.taskwidget.getGroups()
for group in groups:
query = QSqlQuery()
query.prepare("INSERT INTO status (name) VALUES (:name)")
query.bindValue(":name", group.getName())
query.exec_()
query = QSqlQuery("SELECT rowid FROM status WHERE name = '" +
group.getName() + "' ")
query.next()
id_ = query.value(0)
for task in group:
query = QSqlQuery()
query.prepare(
"INSERT INTO tasks (name, status) VALUES (:name, :id)")
query.bindValue(":name", task.getTask())
query.bindValue(":id", id_)
query.exec_()
# Saving maintable
for weeknum in layout.tab.notsaved:
table = layout.tab.getWidgetFromWeeknum(weeknum)
weekdays = [
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
'Sunday'
]
for weekday in weekdays:
tasks = table.getTasks(weekday)
if tasks:
fields = ''
values = ''
for time in tasks:
query = QSqlQuery("SELECT rowid FROM tasks WHERE name ='" +
tasks[time] + "'")
query.next()
tasks[time] = query.value(0)
fields += '"' + time + '"' + ','
values += str(tasks[time]) + ','
fields = 'weekday,' + fields[:-1]
values = '"' + weekday + '_' + str(
weeknum) + '"' + ', ' + values[:-1]
request = 'INSERT INTO main (' + fields + ') VALUES (' + values + ')'
query = QSqlQuery()
query.exec_(request)
layout.tab.notsaved = []
# Saving evaluation values
for week in global_vars.EVAL_VALUES.keys():
val = str(week) + ', '
for value in global_vars.EVAL_VALUES[week]:
val += str(value) + ', '
request = 'INSERT INTO evaluation VALUES(' + val[:-2] + ')'
query = QSqlQuery()
query.exec_(request)
# Saving neural network weights
parent = layout.parentWidget()
exists = True
try:
parent.network
except (AttributeError, NameError):
exists = False
if exists:
hdw = parent.network.hiddenweights
otpw = parent.network.outputweights
request = 'INSERT INTO weights (input, output, value) '
for i in range(len(hdw)):
for j in range(len(hdw[i])):
if (i == 0) and (j == 0):
request += 'SELECT ' + '"in_' + str(
i) + '", "hidden_' + str(j) + '", ' + str(hdw[i][j])
else:
request += ' UNION ALL'
request += ' SELECT ' + '"in_' + str(
i) + '", "hidden_' + str(j) + '", ' + str(hdw[i][j])
for i in range(len(otpw)):
for j in range(len(otpw[i])):
request += ' UNION ALL'
request += ' SELECT ' + '"hidden_' + str(i) + '", "out_' + str(
j) + '", ' + str(hdw[i][j])
print(request)
query = QSqlQuery()
query.exec_(request)
print(query.lastError())
print('Saved')
# Restoring the original state
database.dropConnection()
