def remove(self):
query = QSqlQuery(self.db)
query.prepare("DELETE FROM statistics WHERE pageid=?")
query.addBindValue(self.pageId)
query.exec_()
def execute(self, sql_query):
"""Method used to execute a SQL statement without returning data."""
QSqlQuery().exec_(sql_query)
self.__db.commit()
def buscarLibro(self, Libro):
pattern = re.compile(r"[a-zA-Z0-9ñÑáÁéÉíÍóÓúÚ \.,]+$")
if (pattern.match(Libro) is None):
ErrorPrompt("Caracter inválido", "Caracter inválido en el título")
return
queryText = "SELECT * FROM Book WHERE title = '" + Libro + "';"
self.query = QSqlQuery()
self.query.exec_(queryText)
if (not (self.query.first())):
ErrorPrompt("Error", "No se encontró el libro especificado")
return
self.query2 = QSqlQuery()
self.query2.exec_(
"SELECT num_books_per_loan FROM Estudiante WHERE carnet = '" +
str(self.currentStudent) + "';")
if (not (self.query2.first())):
ErrorPrompt("Error", "Error desconocido")
return
# Cantidad maxima de libros por prestamo del sistema
self.query3 = QSqlQuery()
self.query3.exec_(
"SELECT monto_libro_per_loan FROM Books_per_loan WHERE id = 0;")
self.query3.first()
i = 0
if ((self.query3.value(0) == 0) or (self.query2.value(0) == 0)):
ErrorPrompt(
"Error",
"Se alcanzó el número de libros que este estudiante puede tener en un prestamo."
)
return
while (i != self.tabla_libros_prestamos.rowCount()):
if ((self.tabla_libros_prestamos.item(i, 0).text() == "")
and (i != self.tabla_libros_prestamos.rowCount())):
break
elif (i == self.tabla_libros_prestamos.rowCount()):
ErrorPrompt(
"Error",
"Todas las casillas están llenas, no puede pedir otro libro."
)
return
elif (i + 1 == self.query2.value(0)
or (i + 1 == self.query3.value(0))):
ErrorPrompt(
"Error",
"Se alcanzó el número de libros que este estudiante puede tener en un prestamo."
)
return
i += 1
# Si el libro esta en el diccionario y hay menos ejemplares que el total disponible de ese libro, se le permite agregarlo al prestamo
if (str(Libro) in self.Libros_prestamo.keys()
and self.Libros_prestamo[str(Libro)] <
(self.query.value(4) - self.query.value(5))):
self.Libros_prestamo[str(Libro)] += 1
self.tabla_libros_prestamos.item(i, 0).setText(
str(self.query.value(0)))
self.tabla_libros_prestamos.item(i, 1).setText(str(Libro))
self.tabla_libros_prestamos.cellWidget(i, 2).setEnabled(True)
self.tabla_libros_prestamos.cellWidget(i, 2).setText("X")
# Si el libro no esta en el diccionario, se agrega
elif (str(Libro) not in self.Libros_prestamo.keys()
and (0 < (self.query.value(4) - self.query.value(5)))):
self.Libros_prestamo[str(Libro)] = 0
# Si se estan prestando menos ejemplares que el total disponible de ese libro, se le permite agregarlo al prestamo
if (self.Libros_prestamo[str(Libro)] <
(self.query.value(4) - self.query.value(5))):
self.Libros_prestamo[str(Libro)] = 1
self.tabla_libros_prestamos.item(i, 0).setText(
str(self.query.value(0)))
self.tabla_libros_prestamos.item(i, 1).setText(str(Libro))
self.tabla_libros_prestamos.cellWidget(i, 2).setEnabled(True)
self.tabla_libros_prestamos.cellWidget(i, 2).setText("X")
else:
ErrorPrompt("Error",
"No existen más ejemplares disponibles de este libro")
return
self.button_realizar.setEnabled(True)
self.libro.clear()
def clean(self, table):
with self._lock:
q = QSqlQuery("delete from " + table, self.db)
q.exec_()
def dump(self):
q = QSqlQuery(".dump", db=self.db)
q.exec_()
def __init__(self, parent=None):
super(FaultModel, self).__init__(parent)
self.query = QSqlQuery()
self.dirty = False
self.faults = []
self.checkList = []
def __remove_filters(self):
query = QSqlQuery(self.db)
query.prepare("DELETE FROM filters WHERE pageid=?")
query.addBindValue(self.page.id)
query.exec_()
def viewFilms(self, films):
table = self.uiFlightPathAvailabilityTable
table.setRowCount(0)
self.filmsDict = {}
for film in films:
self.filmsDict[film] = {}
flightPathDirectory = self.settings.value(
"APIS/flightpath_dir") + "\\" + self.yearFromFilm(film)
chkBoxFlightGpsPoint = QCheckBox("nicht verfügbar")
chkBoxFlightGpsPoint.setEnabled(False)
chkBoxFlightGpsPoint.stateChanged.connect(self.checkExportable)
chkBoxFlightGpsLine = QCheckBox("nicht verfügbar")
chkBoxFlightGpsLine.setEnabled(False)
chkBoxFlightGpsLine.stateChanged.connect(self.checkExportable)
chkBoxCameraGpsPoint = QCheckBox("nicht verfügbar")
chkBoxCameraGpsPoint.setEnabled(False)
chkBoxCameraGpsPoint.stateChanged.connect(self.checkExportable)
chkBoxCameraGpsLine = QCheckBox("nicht verfügbar")
chkBoxCameraGpsLine.setEnabled(False)
chkBoxCameraGpsLine.stateChanged.connect(self.checkExportable)
chkBoxImageMappingPoint = QCheckBox("nicht verfügbar")
chkBoxImageMappingPoint.setEnabled(False)
chkBoxImageMappingPoint.stateChanged.connect(self.checkExportable)
chkBoxImageMappingLine = QCheckBox("nicht verfügbar")
chkBoxImageMappingLine.setEnabled(False)
chkBoxImageMappingLine.stateChanged.connect(self.checkExportable)
if os.path.isdir(flightPathDirectory):
if os.path.isfile(flightPathDirectory + "\\" + film +
".shp"): # AND MORE THAN ONE FEATURE
chkBoxFlightGpsPoint.setText("verfügbar")
chkBoxFlightGpsPoint.setEnabled(True)
if os.path.isfile(flightPathDirectory + "\\" + film +
"_lin.shp"):
chkBoxFlightGpsLine.setText("verfügbar")
chkBoxFlightGpsLine.setEnabled(True)
shpFile = flightPathDirectory + "\\" + film + "_gps.shp"
dataSource = self.shpDriver.Open(
shpFile, 0) # 0 means read-only. 1 means writeable.
if dataSource:
ldefn = dataSource.GetLayer().GetLayerDefn()
schema = [
ldefn.GetFieldDefn(n).name
for n in range(ldefn.GetFieldCount())
]
if "bildnr" in schema:
chkBoxCameraGpsPoint.setText("verfügbar")
chkBoxCameraGpsPoint.setEnabled(True)
if dataSource.GetLayer().GetFeatureCount() > 1:
chkBoxCameraGpsLine.setText("verfügbar")
chkBoxCameraGpsLine.setEnabled(True)
# Kartierung
# Input Filmnummer, weise > je nacch weise andere Tabelle (CenterPoint) für Select (COUNT)
# Wenn für Film Bilder kartiert sind ja anzeigen
query = QSqlQuery(self.dbm.db)
#Also load Attributes to be used while exporting, store in self.filmDict
qryStr = "select weise, flugdatum, fotograf, pilot, flugzeug, abflug_zeit, ankunft_zeit, flugzeit, abflug_flughafen, ankunft_flughafen, wetter, target from film where filmnummer = '{0}'".format(
film)
query.exec_(qryStr)
query.first()
rec = query.record()
fn = rec.value(0)
if fn == u"schräg":
orientation = "schraeg"
else:
orientation = "senk"
self.filmsDict[film]['orientation'] = orientation
for col in range(1, rec.count()):
self.filmsDict[film][rec.fieldName(col)] = str(rec.value(col))
qryStr = "select count(*) from luftbild_{0}_cp where filmnummer = '{1}'".format(
orientation, film)
query.exec_(qryStr)
query.first()
fn = query.value(0)
if fn > 0:
chkBoxImageMappingPoint.setText("verfügbar")
chkBoxImageMappingPoint.setEnabled(True)
if fn > 1:
chkBoxImageMappingLine.setText("verfügbar")
chkBoxImageMappingLine.setEnabled(True)
rowPosition = table.rowCount()
table.insertRow(rowPosition)
table.setItem(rowPosition, 0, QTableWidgetItem(film))
table.setCellWidget(rowPosition, 1, chkBoxFlightGpsPoint)
table.setCellWidget(rowPosition, 2, chkBoxFlightGpsLine)
table.setCellWidget(rowPosition, 3, chkBoxCameraGpsPoint)
table.setCellWidget(rowPosition, 4, chkBoxCameraGpsLine)
table.setCellWidget(rowPosition, 5, chkBoxImageMappingPoint)
table.setCellWidget(rowPosition, 6, chkBoxImageMappingLine)
table.resizeRowsToContents()
table.resizeColumnsToContents()
table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
def __init__(self):
self.connection = Connection()
self.query = QSqlQuery(self.connection.connection)
def closedPages(self):
query = QSqlQuery(self.db)
query.prepare("SELECT * FROM pages WHERE isopen=? ORDER BY title")
query.addBindValue(int(False))
query.exec_()
return self.__queryToParam(query)
def getRadioParameters(self):
self.openConnection()
dataList = []
if self.timeFilter:
condition = "WHERE time <= '%s'" % (self.timeFilter)
dataList.append(["Time", self.timeFilter, ""])
elementDictList = [{
"name":
"cdma",
"element":
"Active PN (Best), Ec/Io,RX Power,TX Power,FER,Channel,Band class,N Active Set Cells",
"table":
"cdma",
"column":
"cdma_cell_pn_1, cdma_ecio_1, cdma_rx_power, cdma_tx_power, cdma_fer, cdma_channel, cdma_band_class, cdma_n_aset_cells",
}]
for dic in elementDictList:
temp = []
name = dic["name"]
element = dic["element"]
mainElement = dic["element"]
mainColumn = dic["column"]
subColumn = dic["column"]
table = dic["table"]
join = None
joinString = ""
onString = ""
if element and mainColumn and table:
queryString = """SELECT %s
FROM ( SELECT %s,1 as row_num
FROM %s
%s
ORDER BY time DESC
LIMIT 1
) %s
%s
""" % (
mainColumn,
subColumn,
table,
condition,
name,
joinString,
)
query = QSqlQuery()
query.exec_(queryString)
elements = mainElement.split(",")
if query.first():
for i in range(0, len(elements)):
temp.append([
elements[i],
"" if str(query.value(i)) == "NULL" else
query.value(i),
"",
])
else:
for elem in elements:
temp.append([elem, "", ""])
dataList.extend(temp)
self.closeConnection()
return dataList
def openPage(self, page):
query = QSqlQuery(self.db)
query.prepare("UPDATE pages SET isopen=? WHERE id=?")
query.addBindValue(int(True))
query.addBindValue(page.id)
query.exec_()
def renamePage(self, page, title):
query = QSqlQuery(self.db)
query.prepare("UPDATE pages SET title=? WHERE id=?")
query.addBindValue(title)
query.addBindValue(page.id)
query.exec_()
def pagesParam(self):
if self.params is None:
query = QSqlQuery("SELECT * FROM pages ORDER BY position")
self.params = self.__queryToParam(query)
return self.params
def getActiveSetList(self):
self.openConnection()
dataList = []
condition = ""
maxUnits = 3
if self.timeFilter:
condition = "WHERE time <= '%s'" % (self.timeFilter)
dataList.append([self.timeFilter, "", "", "", "", "", "", ""])
for unit in range(maxUnits):
temp = []
queryString = None
unitNo = unit + 1
# selectedColumns = (
# "wcc.wcdma_cellfile_matched_cellname_%d, wcc.wcdma_celltype_%d, wcc.wcdma_sc_%d, wcc.wcdma_ecio_%d, wcc.wcdma_rscp_%d, wcc.wcdma_cellfreq_%d, wcc.wcdma_cellfreq_%d"
# % (unitNo, unitNo, unitNo, unitNo, unitNo, unitNo, unitNo)
# )
elementDictList = [{
"element": "wcm",
"table": "wcdma_cell_meas",
"column": ("wcdma_aset_cellfreq_%d" % unitNo),
"join": {
"element":
"wafl",
"table":
"wcdma_aset_full_list",
"column":
"wcdma_activeset_psc_%d,wcdma_activeset_cellposition_%d,wcdma_activeset_celltpc_%d,wcdma_activeset_diversity_%d"
% (unitNo, unitNo, unitNo, unitNo),
},
}]
for dic in elementDictList:
element = dic["element"]
mainColumn = dic["column"]
subColumn = dic["column"]
table = dic["table"]
join = None
joinString = ""
onString = ""
if dic["join"]:
join = dic["join"]
joinString = """JOIN ( SELECT %s,1 as row_num
FROM %s
%s
ORDER BY time DESC
LIMIT 1
) %s """ % (
join["column"],
join["table"],
condition,
join["element"],
)
onString = """ON %s.row_num = %s.row_num""" % (
element,
join["element"],
)
mainColumn += ",%s" % join["column"]
if element and mainColumn and table:
queryString = """SELECT %s
FROM ( SELECT %s,1 as row_num
FROM %s
%s
ORDER BY time DESC
LIMIT 1
) %s
%s
%s
""" % (
mainColumn,
subColumn,
table,
condition,
element,
joinString,
onString,
)
query = QSqlQuery()
query.exec_(queryString)
if query.first():
for i in range(0, len(mainColumn.split(","))):
if str(query.value(i)) == "NULL":
temp.append("")
else:
temp.append(query.value(i))
if not all(v == "" for v in temp):
temp.insert(0, "")
dataList.append(temp)
self.closeConnection()
return dataList
def __init__(self):
super(Main, self).__init__()
# ================================================= CARGA FICHERO UI ==================================================
uifile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'InterfaceUI.ui')
uic.loadUi(uifile, self)
# ================================================= INICIA BOTONES ====================================================
# Boton añadir carpeta:
self.boton_anadir_carpeta.clicked.connect(self.fn_boton_anadir_carpeta)
# Boton borrar fichero
self.boton_borrar_fichero.clicked.connect(self.fn_boton_borrar_fichero)
# Boton reset
self.boton_Reset.clicked.connect(self.fn_boton_Reset)
# Botones patogeno
self.boton_AB.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_AB))
self.boton_BC.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_BC))
self.boton_CA.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_CA))
self.boton_EC.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_EC))
self.boton_PA.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_PA))
self.boton_SA.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_SA))
self.boton_MO.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_MO))
self.boton_LE.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_LE))
self.boton_AM.clicked.connect(
lambda: self.obten_nombre_patogeno_analisis(nombre_boton=self.
boton_AM))
# Botones dilucion
self.boton_D1.clicked.connect(
lambda: self.obten_nombre_dilucion(nombre_boton=self.boton_D1))
self.boton_D2.clicked.connect(
lambda: self.obten_nombre_dilucion(nombre_boton=self.boton_D2))
self.boton_D3.clicked.connect(
lambda: self.obten_nombre_dilucion(nombre_boton=self.boton_D3))
self.comboBox_DOtro.currentIndexChanged.connect(
self.obten_nombre_dilucion_comboBox)
# Botones tiempo
self.boton_T0.clicked.connect(
lambda: self.obten_nombre_tiempo(nombre_boton=self.boton_T0))
self.boton_T7.clicked.connect(
lambda: self.obten_nombre_tiempo(nombre_boton=self.boton_T7))
self.boton_T14.clicked.connect(
lambda: self.obten_nombre_tiempo(nombre_boton=self.boton_T14))
self.boton_T28.clicked.connect(
lambda: self.obten_nombre_tiempo(nombre_boton=self.boton_T28))
# Boton zona
self.comboBox_zona.currentIndexChanged.connect(
self.obten_nombre_zona_comboBox)
# Botones ver-ocultar
self.boton_ver.clicked.connect(self.fn_boton_ver)
self.boton_ocultar.clicked.connect(self.fn_boton_ocultar)
# Boton inferencia
self.boton_Evaluar.clicked.connect(self.fn_boton_Evaluar)
# Botones ventana
finish = QAction("Quit", self)
finish.triggered.connect(self.closeEvent)
# Tabla resultados
# columnas = ['ID Placa', 'CH', 'Ref', 'Resultado']
# self.tabla.setColumnCount(4)
# self.tabla.setRowCount(1)
# self.tabla.setHorizontalHeaderLabels(columnas)
# self.tabla.setItem(0, 0, QTableWidgetItem('Hola'))
# self.tabla.cellClicked.connect(self.fn_mostrarItem)
self.db = QSqlDatabase.addDatabase('QODBC')
self.db.setDatabaseName(CONN_STRING)
self.db.open()
self.qry = QSqlQuery(self.db)
self.modelo_query = QSqlQueryModel()
SQL_STATEMENT = 'INSERT INTO dbo.Tabla_Placa(id_TipoAnalisis, id_TipoPatogeno) VALUES (AG, EC)'
self.ejecuta_query(SQL_STATEMENT)
# Botones camara
self.boton_camara.clicked.connect(self.fn_boton_camara)
self.boton_CapturaImagen.clicked.connect(self.fn_boton_CapturaImagen)
self.FLAG_CAMARA_ACTIVA = 0
self.FLAG_CAPTURA_IMAGEN = 0
self.inicializa_nombre_imagen()
# Botones edicion
self.boton_lapiz.clicked.connect(self.fn_boton_lapiz)
self.boton_borrar.clicked.connect(self.fn_boton_borrar)
self.boton_validar.clicked.connect(self.fn_boton_validar)
self.boton_cancelar.clicked.connect(self.fn_boton_cancelar)
self.boton_ausencia.clicked.connect(self.fn_boton_ausencia)
self.boton_presencia.clicked.connect(self.fn_boton_presencia)
self.visor.mousePressEvent = self.mousePressEvent
self.primer_click_x = 0
self.primer_click_y = 0
self.segundo_click_x = 0
self.segundo_click_y = 0
self.lista_nuevas_boxes = []
self.lista_borrar_boxes = []
self.FLAG_DIBUJAR = False
self.FLAG_BORRAR = False
self.FLAG_PRIMER_CLICK = True
self.FLAG_SEGUNDO_CLICK = False
self.FLAG_VALIDAR_EDICION_DETECCION = False
self.FLAG_VALIDAR_EDICION_CLASIFICACION = False
# ================================================= INICIA DIRECTORIOS ============================================
""" El pipeline de este apartado se encarga de obtener y mostrar las imagenes que hay en el directorio, incluyendo
las distintas subcarpetas de tipos de analisis, refererencias, etc. Concretamente, al clicar sobre el directorio
de tipos de analisis, se actualiza su hijo, y asi consecutivamente. Para ello se han creado unas funciones externas
que se encargan de ello. Además, tambien se obtiene la ruta de la imagen objetivo seleccionada para poder usarla
en el resto de funciones de la interfaz. Si el elemento seleccionado es una imagen, se mostrará en el visor. Si
esta imagen se ha inferenciado anteriormente, se mostrará la imagen con las regiones. Si no se ha inferenciado,
se habilitará el botón de evaluacion de placa.
"""
# Asociamos la ruta donde se encuentran las carpetas de los tipos de analisis y creamos el objeto para listar el directorio
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(PATH_IMGS_PRUEBA)
# Mediante la funcion externa, se recorren todos los ficheros existentes en el directorio padre
lista_primer_directorio(self.lista_analisis, self.dirModel)
# Mediante los clicks en las carpetas de los subdirectorios se llama a ciertas funciones que recorren el interior de
# la carpeta seleccionada y lo muestran por pantalla.
self.lista_analisis.clicked.connect(lambda: lista_resto_directorios(
self.lista_analisis, self.lista_lotes, self.lista_imagenes, self.
dirModel, 1))
self.lista_lotes.clicked.connect(lambda: lista_resto_directorios(
self.lista_lotes, self.lista_imagenes, None, self.dirModel))
self.lista_lotes.clicked.connect(
lambda: self.obten_path_del_directorio(Qlist=self.lista_lotes))
self.lista_imagenes.clicked.connect(
lambda: self.obten_path_del_directorio(Qlist=self.lista_imagenes))
def exportToMobile(model, params):
IMAGE_FORMAT = 'jpg'
IMAGE_COMPRESS = 50
USED_FIELDS = ('title', 'unit', 'country', 'year', 'mint', 'mintmark',
'issuedate', 'type', 'series', 'subjectshort', 'material',
'fineness', 'diameter', 'thickness', 'weight', 'mintage',
'rarity', 'obverseimg', 'reverseimg', 'subject', 'price1',
'price2', 'price3', 'price4')
if os.path.isfile(params['file']):
os.remove(params['file'])
db = QSqlDatabase.addDatabase('QSQLITE', 'mobile')
db.setDatabaseName(params['file'])
if not db.open():
print(db.lastError().text())
QMessageBox.critical(None, "Create mobile collection",
"Can't open collection")
return
sql = """CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US')"""
QSqlQuery(sql, db)
sql = """INSERT INTO "android_metadata" VALUES ('en_US')"""
QSqlQuery(sql, db)
mobile_settings = {
'Version': 1,
'Type': 'MobilePro',
'Filter': params['filter']
}
sql = """CREATE TABLE settings (
title CHAR NOT NULL UNIQUE,
value CHAR)"""
QSqlQuery(sql, db)
for key, value in mobile_settings.items():
query = QSqlQuery(db)
query.prepare("""INSERT INTO settings (title, value)
VALUES (?, ?)""")
query.addBindValue(key)
query.addBindValue(str(value))
query.exec_()
sql = """CREATE TABLE updates (
title CHAR NOT NULL UNIQUE,
value CHAR)"""
QSqlQuery(sql, db)
sql = """INSERT INTO updates (title, value)
VALUES ('160203', '2016-02-03T10:19:00')"""
QSqlQuery(sql, db)
sql = """CREATE TABLE photos (
id INTEGER PRIMARY KEY,
image BLOB)"""
QSqlQuery(sql, db)
sql = """CREATE TABLE coins (
id INTEGER PRIMARY KEY,
description_id INTEGER,
grade INTEGER,
createdat STRING)"""
QSqlQuery(sql, db)
sql = """CREATE INDEX coins_descriptions ON coins(description_id)"""
QSqlQuery(sql, db)
sqlFields = []
fields = CollectionFieldsBase()
for field in fields:
if field.name == 'id':
sqlFields.append('id INTEGER PRIMARY KEY')
elif field.name == 'image':
sqlFields.append('image INTEGER')
elif field.name in USED_FIELDS:
sqlFields.append("%s %s" % (field.name, Type.toSql(field.type)))
sql = "CREATE TABLE descriptions (" + ", ".join(sqlFields) + ")"
QSqlQuery(sql, db)
while model.canFetchMore():
model.fetchMore()
dest_model = QSqlTableModel(None, db)
dest_model.setEditStrategy(QSqlTableModel.OnManualSubmit)
dest_model.setTable('descriptions')
dest_model.select()
height = 64
if params['density'] == 'HDPI':
height *= 1.5
elif params['density'] == 'XHDPI':
height *= 2
elif params['density'] == 'XXHDPI':
height *= 3
elif params['density'] == 'XXXHDPI':
height *= 4
maxHeight = height * 4
is_obverse_enabled = params['image'] in (ExportDialog.IMAGE_OBVERSE,
ExportDialog.IMAGE_BOTH)
is_reverse_enabled = params['image'] in (ExportDialog.IMAGE_REVERSE,
ExportDialog.IMAGE_BOTH)
fields = CollectionFieldsBase()
count = model.rowCount()
progressDlg = Gui.ProgressDialog("Exporting records", "Cancel", count,
None)
for i in range(count):
progressDlg.step()
if progressDlg.wasCanceled():
break
coin = model.record(i)
if coin.value('status') in ('pass', 'sold'):
continue
dest_record = dest_model.record()
for field in fields:
if field.name in ('id', 'image', 'obverseimg', 'reverseimg'):
continue
if field.name in USED_FIELDS:
val = coin.value(field.name)
if val is None or val == '':
continue
dest_record.setValue(field.name, val)
# Process images
is_obverse_present = not coin.isNull('obverseimg')
is_reverse_present = not coin.isNull('reverseimg')
if is_obverse_present or is_reverse_present:
obverseImage = QImage()
reverseImage = QImage()
if is_obverse_present:
ba = QtCore.QByteArray()
buffer = QtCore.QBuffer(ba)
buffer.open(QtCore.QIODevice.WriteOnly)
obverseImage.loadFromData(coin.value('obverseimg'))
if not obverseImage.isNull() and not params[
'fullimage'] and obverseImage.height() > maxHeight:
scaledImage = obverseImage.scaled(maxHeight, maxHeight,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
scaledImage.save(buffer, IMAGE_FORMAT, IMAGE_COMPRESS)
save_data = ba
else:
if not obverseImage.isNull():
obverseImage.save(buffer, IMAGE_FORMAT, IMAGE_COMPRESS)
save_data = ba
else:
save_data = coin.value('obverseimg')
query = QSqlQuery(db)
query.prepare("""INSERT INTO photos (image)
VALUES (?)""")
query.addBindValue(save_data)
query.exec_()
img_id = query.lastInsertId()
dest_record.setValue('obverseimg', img_id)
if not obverseImage.isNull():
obverseImage = obverseImage.scaledToHeight(
height, Qt.SmoothTransformation)
if is_reverse_present:
ba = QtCore.QByteArray()
buffer = QtCore.QBuffer(ba)
buffer.open(QtCore.QIODevice.WriteOnly)
reverseImage.loadFromData(coin.value('reverseimg'))
if not reverseImage.isNull() and not params[
'fullimage'] and reverseImage.height() > maxHeight:
scaledImage = reverseImage.scaled(maxHeight, maxHeight,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
scaledImage.save(buffer, IMAGE_FORMAT, IMAGE_COMPRESS)
save_data = ba
else:
if not reverseImage.isNull():
reverseImage.save(buffer, IMAGE_FORMAT, IMAGE_COMPRESS)
save_data = ba
else:
save_data = coin.value('reverseimg')
query = QSqlQuery(db)
query.prepare("""INSERT INTO photos (image)
VALUES (?)""")
query.addBindValue(save_data)
query.exec_()
img_id = query.lastInsertId()
dest_record.setValue('reverseimg', img_id)
if not reverseImage.isNull():
reverseImage = reverseImage.scaledToHeight(
height, Qt.SmoothTransformation)
if not is_obverse_enabled:
obverseImage = QImage()
if not is_reverse_enabled:
reverseImage = QImage()
image = QImage(obverseImage.width() + reverseImage.width(), height,
QImage.Format_RGB32)
image.fill(QColor(Qt.white).rgb())
paint = QPainter(image)
if is_obverse_present and is_obverse_enabled:
paint.drawImage(
QtCore.QRectF(0, 0, obverseImage.width(), height),
obverseImage,
QtCore.QRectF(0, 0, obverseImage.width(), height))
if is_reverse_present and is_reverse_enabled:
paint.drawImage(
QtCore.QRectF(obverseImage.width(), 0,
reverseImage.width(), height), reverseImage,
QtCore.QRectF(0, 0, reverseImage.width(), height))
paint.end()
ba = QtCore.QByteArray()
buffer = QtCore.QBuffer(ba)
buffer.open(QtCore.QIODevice.WriteOnly)
image.save(buffer, IMAGE_FORMAT, 75)
query = QSqlQuery(db)
query.prepare("""INSERT INTO photos (image)
VALUES (?)""")
query.addBindValue(ba)
query.exec_()
img_id = query.lastInsertId()
dest_record.setValue('image', img_id)
dest_model.insertRecord(-1, dest_record)
progressDlg.setLabelText("Saving...")
dest_model.submitAll()
progressDlg.setLabelText("Compact...")
QSqlQuery(
"""UPDATE descriptions
SET
reverseimg = (select t2.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.reverseimg = t1.id where t1.id <> t2.id and t3.id = descriptions.id)
WHERE descriptions.id in (select t3.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.reverseimg = t1.id where t1.id <> t2.id)
""", db)
QSqlQuery(
"""UPDATE descriptions
SET
obverseimg = (select t2.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.obverseimg = t1.id where t1.id <> t2.id and t3.id = descriptions.id)
WHERE descriptions.id in (select t3.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.obverseimg = t1.id where t1.id <> t2.id)
""", db)
QSqlQuery(
"""UPDATE descriptions
SET
image = (select t2.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.image = t1.id where t1.id <> t2.id and t3.id = descriptions.id)
WHERE descriptions.id in (select t3.id from descriptions t3 join (select id, image from photos group by image having count(*) > 1) t2 on t1.image = t2.image join photos t1 on t3.image = t1.id where t1.id <> t2.id)
""", db)
QSqlQuery(
"""DELETE FROM photos
WHERE id NOT IN (SELECT id FROM photos GROUP BY image)""", db)
db.close()
progressDlg.setLabelText("Vacuum...")
db = QSqlDatabase.addDatabase('QSQLITE', 'mobile')
db.setDatabaseName(params['file'])
if not db.open():
print(db.lastError().text())
QMessageBox.critical(None, "Create mobile collection",
"Can't open collection")
return
QSqlQuery("VACUUM", db)
db.close()
progressDlg.reset()
def deleteQuery():
query = QSqlQuery()
query.exec('DELETE FROM %s WHERE Id = %s' % (table, id))
def query(self):
return QSqlQuery()
def insertDose(ingredient_id, pastry_id, count):
query = QSqlQuery()
query.exec('INSERT INTO Doses (Ingredient, Pastry, Count) '
'VALUES (%s, %s, %s)' % (ingredient_id, pastry_id, count))
def __init__(self, page):
super().__init__(page)
self.__lists_changed = False
self.page = page
self.db = page.db
if 'lists' not in self.db.tables():
sql = """CREATE TABLE lists (
id INTEGER PRIMARY KEY,
pageid INTEGER,
fieldid INTEGER,
position INTEGER,
enabled INTEGER,
width INTEGER,
sortorder INTEGER)"""
QSqlQuery(sql, self.db)
query = QSqlQuery(self.db)
query.prepare("SELECT * FROM lists WHERE pageid=? ORDER BY position")
query.addBindValue(self.page.id)
query.exec_()
self.columns = []
while query.next():
param = ColumnListParam(query.record())
self.columns.append(param)
self.fields = page.fields
# Create default parameters
if not self.columns:
for field in self.fields.userFields:
enabled = False
if field.name in ('image', 'title', 'value', 'unit',
'country', 'year', 'status'):
enabled = True
param = ColumnListParam(field.id, enabled)
self.columns.append(param)
if 'filters' not in self.db.tables():
sql = """CREATE TABLE filters (
id INTEGER PRIMARY KEY,
pageid INTEGER,
fieldid INTEGER,
value INTEGER,
blank INTEGER,
data INTEGER,
revert INTEGER)"""
QSqlQuery(sql, self.db)
query = QSqlQuery(self.db)
query.prepare("SELECT * FROM filters WHERE pageid=?")
query.addBindValue(self.page.id)
query.exec_()
self.filters = {}
while query.next():
fieldId = query.record().value('fieldid')
column_name = self.fields.field(fieldId).name
if not query.record().isNull('value'):
value = str(query.record().value('value'))
filter_ = ValueFilter(column_name, value)
if not query.record().isNull('data'):
if query.record().value('data'):
filter_ = DataFilter(column_name)
if not query.record().isNull('blank'):
if query.record().value('blank'):
filter_ = BlankFilter(column_name)
if not query.record().isNull('revert'):
if query.record().value('revert'):
filter_.revert = True
if fieldId not in self.filters.keys():
self.filters[fieldId] = ColumnFilters(column_name)
self.filters[fieldId].addFilter(filter_)
def updateToggleSwitchSix(self, model):
# ids = int(model.get_light_name_1())
_toggle_switch_6 = model.get_toggle_switch_6()
query = QSqlQuery(configVariables.db_history)
query.exec_("UPDATE switchControl SET toggle_switch_6 ='" +
str(_toggle_switch_6) + "' WHERE id= 1")
def clone(self):
q = QSqlQuery(".dump", self.db)
q.exec_()
def updateHumSwitchData(self, model):
# ids = int(model.get_light_name_1())
_switch_hum_ctrl = model.get_switch_hum_ctrl()
query = QSqlQuery(configVariables.db_history)
query.exec_("UPDATE switchControl SET set_hum ='" +
str(_switch_hum_ctrl) + "' WHERE id= 1")
def _create_tables(self):
# https://www.sqlite.org/wal.html
q = QSqlQuery("PRAGMA journal_mode = OFF", self.db)
q.exec_()
q = QSqlQuery("PRAGMA synchronous = OFF", self.db)
q.exec_()
q = QSqlQuery("PRAGMA cache_size=10000", self.db)
q.exec_()
q = QSqlQuery("PRAGMA optimize", self.db)
q.exec_()
q = QSqlQuery("create table if not exists connections (" \
"time text, " \
"node text, " \
"action text, " \
"protocol text, " \
"src_ip text, " \
"src_port text, " \
"dst_ip text, " \
"dst_host text, " \
"dst_port text, " \
"uid text, " \
"pid text, " \
"process text, " \
"process_args text, " \
"process_cwd text, " \
"rule text, " \
"UNIQUE(node, action, protocol, src_ip, src_port, dst_ip, dst_port, uid, pid, process, process_args))",
self.db)
q = QSqlQuery("create index action_index on connections (action)",
self.db)
q.exec_()
q = QSqlQuery("create index protocol_index on connections (protocol)",
self.db)
q.exec_()
q = QSqlQuery("create index dst_host_index on connections (dst_host)",
self.db)
q.exec_()
q = QSqlQuery("create index process_index on connections (process)",
self.db)
q.exec_()
q = QSqlQuery("create index dst_ip_index on connections (dst_ip)",
self.db)
q.exec_()
q = QSqlQuery("create index dst_port_index on connections (dst_port)",
self.db)
q.exec_()
q = QSqlQuery("create index rule_index on connections (rule)", self.db)
q.exec_()
q = QSqlQuery("create index node_index on connections (node)", self.db)
q.exec_()
q = QSqlQuery("create table if not exists rules (" \
"time text, " \
"node text, " \
"name text, " \
"enabled text, " \
"precedence text, " \
"action text, " \
"duration text, " \
"operator_type text, " \
"operator_sensitive text, " \
"operator_operand text, " \
"operator_data text, " \
"UNIQUE(node, name)"
")", self.db)
q.exec_()
q = QSqlQuery(
"create table if not exists hosts (what text primary key, hits integer)",
self.db)
q.exec_()
q = QSqlQuery(
"create table if not exists procs (what text primary key, hits integer)",
self.db)
q.exec_()
q = QSqlQuery(
"create table if not exists addrs (what text primary key, hits integer)",
self.db)
q.exec_()
q = QSqlQuery(
"create table if not exists ports (what text primary key, hits integer)",
self.db)
q.exec_()
q = QSqlQuery(
"create table if not exists users (what text primary key, hits integer)",
self.db)
q.exec_()
q = QSqlQuery("create table if not exists nodes (" \
"addr text primary key," \
"hostname text," \
"daemon_version text," \
"daemon_uptime text," \
"daemon_rules text," \
"cons text," \
"cons_dropped text," \
"version text," \
"status text, " \
"last_connection text)"
, self.db)
q.exec_()
def db_create(self):
print("DB_create:" + str(configVariables.db_history.open()))
query = QSqlQuery(configVariables.db_history)
query.exec_(
"create table history_table(id INTEGER PRIMARY KEY , "
"date_time varchar(60) NOT NULL UNIQUE, hwclock_date, hwclock_time varchar(60) NOT NULL UNIQUE, "
"alarm_history varchar(20), gas_name varchar(60))")
query.exec_(
"create table graph_table(id INTEGER PRIMARY KEY , "
"temp_value varchar(60), "
"date_time varchar(60) NOT NULL UNIQUE, running_pass_time varchar(20) , hum_value varchar(60))"
)
'''query = QSqlQuery(configVariables.db_light)
query.exec_("create table light_table(id INTEGER PRIMARY KEY , "
" sw_1 varchar(20), sw_2 varchar(20), sw_3 varchar(20), sw_4 varchar(20), sw_5 varchar(20),"
" sw_6 varchar(20), intensity_1 varchar(20), intensity_2 varchar(20), intensity_3 varchar(20), "
" intensity_4 varchar(20))")'''
query_image = QSqlQuery(configVariables.db_image)
query.exec_(
"create table image_table(id INTEGER PRIMARY KEY , "
"play_wh BLOB, pause_wh BLOB, changed_light_bulb BLOB,"
"changed_ot_light BLOB, low_light_bulb BLOB, low_ot_light BLOB,"
"on_speaker BLOB, off_speaker BLOB,"
"changed_low_color varchar(80))")
query.exec_(
"create table switchControl(id INTEGER PRIMARY KEY ,"
"toggle_switch_1 varchar(10), toggle_switch_2 varchar(10),"
"toggle_switch_3 varchar(10), toggle_switch_4 varchar(10),"
"toggle_switch_5 varchar(10), toggle_switch_6 varchar(10),"
"hours_cnt INTEGER, minutes_cnt INTEGER, seconds_cnt INTEGER, set_hum INTEGER, "
"set_temp INTEGER, sound_on_off_flag INTEGER, mute_flag INTEGER)")
query.exec_(
"insert into switchControl(toggle_switch_1, toggle_switch_2, "
"toggle_switch_3, toggle_switch_4,"
"toggle_switch_5, toggle_switch_6,"
"hours_cnt, minutes_cnt, seconds_cnt,"
"set_hum, set_temp, sound_on_off_flag, mute_flag) values("
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1)")
'''query.exec_("create table GeneralSettings(id INTEGER PRIMARY KEY , "
"light_name_1 varchar(20), light_name_2 varchar(20), light_name_3 varchar(20), light_name_4 "
"varchar(20), light_name_5 varchar(20), light_name_6 varchar(20), light_checkbox_1 varchar(20), "
"light_checkbox_2 varchar(20), light_checkbox_3 varchar(20), light_checkbox_4 varchar(20), "
"light_checkbox_5 varchar(20), light_checkbox_6 varchar(20),gas_name_1 "
"varchar(20), gas_name_2 varchar(20), gas_name_3 varchar(20), gas_name_4 varchar(20), gas_name_5 "
"varchar(20), gas_name_6 varchar(20),gas_name_7 varchar(20), gas_checkbox_1 varchar(20), "
"gas_checkbox_2 varchar(20), "
"gas_checkbox_3 varchar(20), gas_checkbox_4 varchar(20), gas_checkbox_5 varchar(20), "
"gas_checkbox_6 varchar(20), gas_checkbox_7 varchar(20),dim_checkbox_1 varchar(20), "
"dim_checkbox_2 varchar(20), "
"dim_checkbox_3 varchar(20), dim_checkbox_4 varchar(20), differential_gas_pressure_checkbox "
"varchar(20))")'''
'''
def queryAppearanceSettingsData(self, model):
query = QSqlQuery()
query.exec_("SELECT * FROM AppearanceSettings where id=1")
while query.next():
model.set_theme_color(query.value('theme_color'))
model.set_appearance_theme_color_name(query.value('appearance_color_name'))
model.set_theme_color_preview(query.value('theme_color_preview_image_path'))
model.set_enable_disable_background_image(query.value('back_image_enable_disable'))
model.set_background_image_path(query.value('background_image_path'))
print("Query: " + query.value('background_image_path'))
model.set_enable_disable_logo_image(query.value('logo_enable_disable'))
model.set_logo_image_path(query.value('logo_path'))
model.set_power_on_image_path(query.value('power_on_image_path'))
model.set_combo_theme_color_index(query.value('theme_color_index'))
def updateBackgroundImagePath(self, model):
# ids = int(model.get_light_name_1())
_background_image_path = model.get_background_image_path()
query = QSqlQuery()
query.exec_("UPDATE AppearanceSettings SET background_image_path ='" + _background_image_path + "' WHERE id= 1")
'''
''' if __name__ == "__main__":
def buscarEstudiante(self, carnetBuscado):
pattern = re.compile(r"\d\d\-\d{5}")
if (pattern.match(carnetBuscado) is None):
ErrorPrompt("Error de formato", "Formato de carnet inválido")
return
queryText = "SELECT * FROM Estudiante WHERE carnet = '" + carnetBuscado + "';"
self.query = QSqlQuery()
self.query2 = QSqlQuery()
self.query2.exec_(queryText)
queryText = "SELECT L.book_id, B.title, L.estimated_return_time FROM Loan L, Book B WHERE L.carnet = '" + carnetBuscado + "' AND L.book_id = B.book_id;"
self.query.exec_(queryText)
# Si no existe el estudiante
if (not (self.query2.first())):
ErrorPrompt("Error", "No se encontró un estudiante con ese carnet")
return
# Si existe estudiante y tiene prestamo activo
elif (self.query.first()):
self.currentStudent = carnetBuscado
self.tabla_libros_prestamos.clear()
self.Libros_prestamo.clear()
self.nombre.setText(str(self.query2.value(1)))
self.apellido.setText(str(self.query2.value(2)))
self.deuda.setText(str(self.query2.value(9)))
self.button_renovar.setEnabled(False)
self.tabla_libros_prestamos.clear()
self.prestamo.setText("Prestamo activo")
self.libro.setEnabled(False)
self.button_agregar_libro.setEnabled(False)
self.button_realizar.setEnabled(False)
self.button_devuelto.setEnabled(True)
# Si le queda menos de 1 dia para regresar el libro, permitimos la renovacion
time_left = 10000
i = 0
while (True):
self.tabla_libros_prestamos.item(i, 0).setText(
str(self.query.value(0)))
self.tabla_libros_prestamos.item(i, 1).setText(
str(self.query.value(1)))
# Buscamos el intervalo de prestamo mas pequeño y ese sera el intervalo de prestamo del prestamo
if (self.calculateTimeLeft(QDateTime.currentDateTime(),
self.query.value(2)) <= time_left):
time_left = self.calculateTimeLeft(
QDateTime.currentDateTime(), self.query.value(2))
i += 1
if (not self.query.next()):
break
# Si al prestamo le falta 1 dia para vencerse, se deja renovar
if (-1 < time_left < 2):
self.button_renovar.setEnabled(True)
return
# Si existe Estudiante pero no tiene prestamo activo
self.currentStudent = carnetBuscado
self.tabla_libros_prestamos.clear()
self.Libros_prestamo.clear()
self.nombre.setText(str(self.query2.value(1)))
self.apellido.setText(str(self.query2.value(2)))
self.deuda.setText(str(self.query2.value(9)))
self.button_renovar.setEnabled(False)
self.tabla_libros_prestamos.clear()
self.prestamo.setText("No préstamo activo")
if (float(self.deuda.text()) == 0):
self.libro.setEnabled(True)
self.button_agregar_libro.setEnabled(True)
self.button_devuelto.setEnabled(False)
self.button_renovar.setEnabled(False)
return
def getRadioParameters(self):
self.openConnection()
dataList = []
if self.timeFilter:
condition = "WHERE time <= '%s'" % (self.timeFilter)
dataList.append(["Time", self.timeFilter, ""])
elementDictList = [{
"name":
"wtp",
"element":
"Tx Power,Max Tx Power",
"table":
"wcdma_tx_power",
"column":
"wcdma_txagc,wcdma_maxtxpwr",
"join": [
{
"name": "wrp",
"element": "RSSI",
"table": "wcdma_rx_power",
"column": "wcdma_rssi",
},
{
"name": "ws",
"element": "SIR",
"table": "wcdma_sir",
"column": "wcdma_sir",
},
{
"name": "wrs",
"element": "RRC State",
"table": "wcdma_rrc_state",
"column": "wcdma_rrc_state",
},
{
"name": "vi",
"element": "Speech Codec TX,Speech Codec RX",
"table": "vocoder_info",
"column": "gsm_speechcodectx,gsm_speechcodecrx",
},
{
"name": "ai",
"element": "Cell ID,RNC ID",
"table": "android_info_1sec",
"column": "android_cellid,android_rnc_id",
},
],
}]
for dic in elementDictList:
temp = []
name = dic["name"]
element = dic["element"]
mainElement = dic["element"]
mainColumn = dic["column"]
subColumn = dic["column"]
table = dic["table"]
join = None
joinString = ""
onString = ""
if not len(dic["join"]) == 0:
for join in dic["join"]:
onString = """ON %s.row_num = %s.row_num""" % (
name,
join["name"],
)
joinString += """LEFT JOIN ( SELECT %s,1 as row_num
FROM %s
%s
ORDER BY time DESC
LIMIT 1
) %s
%s """ % (
join["column"],
join["table"],
condition,
join["name"],
onString,
)
mainColumn += ",%s" % join["column"]
mainElement += ",%s" % join["element"]
if element and mainColumn and table:
queryString = """SELECT %s
FROM ( SELECT %s,1 as row_num
FROM %s
%s
ORDER BY time DESC
LIMIT 1
) %s
%s
""" % (
mainColumn,
subColumn,
table,
condition,
name,
joinString,
)
query = QSqlQuery()
query.exec_(queryString)
elements = mainElement.split(",")
if query.first():
for i in range(0, len(elements)):
temp.append([
elements[i],
"" if str(query.value(i)) == "NULL" else
query.value(i),
"",
])
else:
for elem in elements:
temp.append([elem, "", ""])
dataList.extend(temp)
self.closeConnection()
return dataList
def realizarPrestamo(self, Username):
titles = ""
if (self.tabla_libros_prestamos.item(0, 0).text() == ""):
ErrorPrompt("Error",
"Debe agregar libros para realizar un prestamo")
return
self.query = QSqlQuery()
self.queryTitle = QSqlQuery()
self.queryMail = QSqlQuery()
self.queryMail.exec_("SELECT email FROM Estudiante WHERE carnet = \'" +
self.currentStudent + "\'")
if self.queryMail.first():
address = str(self.queryMail.value(0))
else:
ErrorPrompt(
"Error",
"No se pudo realizar el préstamo. Estudiante no tiene email")
return
start_date = str(datetime.datetime.now())
hours = start_date.split()
i = 0
while (i != self.tabla_libros_prestamos.rowCount()):
if (self.tabla_libros_prestamos.item(i, 0).text() != ""):
queryText = "INSERT INTO Loan (carnet, lender, start_time, book_id, copy_id, estimated_return_time) VALUES ('" + self.currentStudent + "', '" + Username + "', '" + start_date + "', "
self.query.exec_(
"SELECT loan_duration FROM Book WHERE book_id = '" +
self.tabla_libros_prestamos.item(i, 0).text() + "';")
# Aqui completamos el queryText con la informacion faltante y restamos la cantidad de copias de cada libro en el diccionario
if (self.query.first()):
return_date = str(
datetime.date.today() + datetime.timedelta(
days=(self.query.value(0)))) + " " + str(hours[1])
queryText = queryText + "'" + str(
self.tabla_libros_prestamos.item(i, 0).text()
) + "', '" + str(self.Libros_prestamo[str(
self.tabla_libros_prestamos.item(
i, 1).text())]) + "', '" + return_date + "');"
self.Libros_prestamo[str(
self.tabla_libros_prestamos.item(i, 1).text())] -= 1
# Se actualiza la cantidad de copias prestadas del libro
self.query.exec_(
"UPDATE Book SET quantity_lent = quantity_lent + 1 WHERE book_id='"
+ str(self.tabla_libros_prestamos.item(i, 0).text()) +
"';")
self.query.exec_(
"UPDATE Estudiante SET current_books = current_books + 1 WHERE carnet='"
+ str(self.currentStudent) + "';")
# Se realiza la insercion a la tabla Loan, es decir, se realiza el prestamo
self.query.exec_(queryText)
self.prestamoToLog(
self.currentStudent, Username,
self.tabla_libros_prestamos.item(i, 0).text(),
start_date, return_date)
self.queryTitle.exec_(
"SELECT title FROM Book WHERE book_id = " +
str(self.tabla_libros_prestamos.item(i, 0).text()))
if self.queryTitle.first():
titles += str(self.queryTitle.value(0))
else:
titles += str(
self.tabla_libros_prestamos.item(i, 0).text())
titles += "\n"
i += 1
else:
ErrorPrompt("Error", "No se pudo realizar el préstamo")
return
else:
break
self.sendConfirmEmail(address, "Préstamo", titles, return_date)
InfoPrompt("Éxito", "Se realizó el préstamo!")
self.libro.setText("")
self.updateActiveLoanTable()
self.buscarEstudiante(self.currentStudent)
def update_schema_migrations_level(migration):
query = QSqlQuery()
query.prepare("INSERT INTO migrations (level) VALUES (:level)")
query.bindValue(':level', migration.level)
if not query.exec_():
fail_migration(query, migration.path)
