def afterCommit_flfiles(self, cur_files_: "isqlcursor.ISqlCursor") -> bool:
"""After commit flfiles."""
if cur_files_.modeAccess() != cur_files_.Browse:
_qry = qsa.FLSqlQuery()
_qry.setTablesList(u"flserial")
_qry.setSelect(u"sha")
_qry.setFrom(u"flfiles")
_qry.setForwardOnly(True)
_serial_value = cur_files_.valueBuffer(u"sha")
if _qry.exec_():
if _qry.first():
util = qsa.FLUtil()
_v = util.sha1(_qry.value(0))
while _qry.next():
if _qry.value(0) is not None:
_v = util.sha1(_v + _qry.value(0))
_serial_value = _v
_cur_serial = qsa.FLSqlCursor(u"flserial")
_cur_serial.select()
if _cur_serial.first():
_cur_serial.setModeAccess(_cur_serial.Edit)
else:
_cur_serial.setModeAccess(_cur_serial.Insert)
_cur_serial.refreshBuffer()
_cur_serial.setValueBuffer(u"sha", _serial_value)
_cur_serial.commitBuffer()
return True
def test_sqlSelect(self) -> None:
"""Test sqlSelect."""
from pineboolib.qsa import qsa
cursor_areas = qsa.FLSqlCursor("flareas")
cursor_areas.setModeAccess(cursor_areas.Insert)
cursor_areas.refreshBuffer()
cursor_areas.setValueBuffer("idarea", "Y")
cursor_areas.setValueBuffer("descripcion", "123oX")
self.assertTrue(cursor_areas.commitBuffer())
cx = cursor_areas.db()
util = qsa.FLUtil()
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'"), "123oX")
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'",
["flareas"]), "123oX")
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'", ["flareas"],
0), "123oX")
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'", ["flareas"],
cx), "123oX")
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'", ["flareas"],
0, "default"),
"123oX",
)
self.assertEqual(
util.sqlSelect("flareas", "descripcion", "idarea='Y'", ["flareas"],
0, cx), "123oX")
def test_kugar_parser_1(self) -> None:
"""Test parser."""
from pineboolib.qsa import qsa
from pineboolib.plugins.mainform.eneboo import eneboo
import os
application.PROJECT.main_form = eneboo
# application.project.main_form.mainWindow = application.project.main_form.MainForm()
# application.project.main_form.mainWindow.initScript()
# application.project.main_window = application.project.main_form.mainWindow
application.PROJECT.main_window = application.PROJECT.main_form.MainForm(
) # type: ignore
application.PROJECT.main_window.initScript()
qsa_sys = qsa.sys
path = fixture_path("principal.eneboopkg")
self.assertTrue(os.path.exists(path))
qsa_sys.loadModules(path, False)
qsa.from_project("flfactppal").iface.valoresIniciales()
cur_paises = qsa.FLSqlCursor("paises")
"""
cur_paises.setModeAccess(cur_paises.Insert)
cur_paises.refreshBuffer()
cur_paises.setValueBuffer("codpais", "ES")
cur_paises.setValueBuffer("nombre", "ESPAÑA")
self.assertTrue(cur_paises.commitBuffer())
cur_paises.setModeAccess(cur_paises.Insert)
cur_paises.refreshBuffer()
cur_paises.setValueBuffer("codpais", "PT")
cur_paises.setValueBuffer("nombre", "PORTUGAL")
self.assertTrue(cur_paises.commitBuffer())
"""
cur_paises.select("1=1")
cur_paises.first()
init_ = cur_paises.valueBuffer("codpais")
cur_paises.last()
last_ = cur_paises.valueBuffer("codpais")
qry_paises = qsa.FLSqlQuery("paises")
qry_paises.setValueParam("from", init_)
qry_paises.setValueParam("to", last_)
rpt_viewer_ = qsa.FLReportViewer()
rpt_viewer_.setReportTemplate("paises")
rpt_viewer_.setReportData(qry_paises)
rpt_viewer_.renderReport()
if rpt_viewer_.rptEngine_ and hasattr(rpt_viewer_.rptEngine_,
"parser_"):
pdf_file = rpt_viewer_.rptEngine_.parser_.get_file_name()
self.assertTrue(pdf_file)
def test_transaction_level(self) -> None:
from pineboolib.qsa import qsa
from pineboolib.application.metadata import pnrelationmetadata
sys_1 = systype.SysType()
sys_2 = qsa.sys
self.assertEqual(sys_1.transactionLevel(), 0)
self.assertEqual(sys_2.transactionLevel(), 0)
cur_areas = qsa.FLSqlCursor("flareas")
cursor = qsa.FLSqlCursor("flareas")
cursor.setModeAccess(cursor.Insert)
cursor.refreshBuffer()
cursor.setValueBuffer("bloqueo", True)
cursor.setValueBuffer("idarea", "H")
cursor.setValueBuffer("descripcion", "Área de prueba H")
self.assertTrue(cursor.commitBuffer())
rel = pnrelationmetadata.PNRelationMetaData(
"flareas", "idarea",
pnrelationmetadata.PNRelationMetaData.RELATION_1M)
rel.setField("idarea")
cur_areas.select("idarea ='H'")
cur_areas.first()
self.assertEqual(cur_areas.valueBuffer("idarea"), "H")
cur_areas.setModeAccess(cur_areas.Edit)
cur_areas.refreshBuffer()
cur_modulos = qsa.FLSqlCursor("flmodules", True, "default", cur_areas,
rel)
cur_modulos.select()
cur_modulos.refreshBuffer()
self.assertEqual(sys_1.transactionLevel(), 0)
self.assertEqual(sys_2.transactionLevel(), 0)
cur_modulos.setModeAccess(cur_modulos.Insert)
cur_modulos.transaction()
self.assertEqual(sys_1.transactionLevel(), 1)
self.assertEqual(sys_2.transactionLevel(), 1)
self.assertTrue(cur_modulos.rollback())
def test_initialization(self) -> None:
"""Test flformrecord cursor assignment"""
from pineboolib.qsa import qsa
import os
path = fixture_path("principal.eneboopkg")
self.assertTrue(os.path.exists(path))
qsa.sys.loadModules(path, False)
form_search_1 = qsa.FLFormSearchDB("bancos")
self.assertEqual(form_search_1.cursor().metadata().name(), "bancos")
self.assertEqual(form_search_1.action().name(), "bancos")
self.assertEqual(form_search_1.parent(), QtWidgets.QApplication.activeModalWidget())
parent_2 = QtWidgets.QWidget()
form_search_2 = qsa.FLFormSearchDB("clientes", parent_2)
self.assertEqual(form_search_2.cursor().metadata().name(), "clientes")
self.assertEqual(form_search_2.action().name(), "clientes")
self.assertEqual(form_search_2.parent(), parent_2)
parent_3 = QtWidgets.QWidget()
cur_3 = qsa.FLSqlCursor("proveedores")
form_search_3 = qsa.FLFormSearchDB(cur_3, "proveedores", parent_3)
self.assertEqual(form_search_3.cursor().metadata().name(), "proveedores")
self.assertEqual(form_search_3.action().name(), "proveedores")
self.assertEqual(form_search_3.parent(), parent_3)
self.assertEqual(form_search_3.cursor(), cur_3)
parent_4 = None
cur_4 = qsa.FLSqlCursor("proveedores")
form_search_4 = qsa.FLFormSearchDB(cur_4, "proveedores", parent_4)
self.assertEqual(form_search_4.cursor().metadata().name(), "proveedores")
self.assertEqual(form_search_4.action().name(), "proveedores")
self.assertEqual(form_search_4.parent(), QtWidgets.QApplication.activeModalWidget())
self.assertEqual(form_search_4.cursor(), cur_4)
def test_flsqlquery_date_null(self) -> None:
"""Test FLSqlQuery date null."""
from pineboolib.qsa import qsa
cursor = qsa.FLSqlCursor("fltest")
cursor.setModeAccess(cursor.Insert)
cursor.refreshBuffer()
self.assertTrue(cursor.commitBuffer())
qry = qsa.FLSqlQuery()
qry.setTablesList("fltest")
qry.setSelect("date_field")
qry.setFrom("fltest")
qry.setWhere("1=1 LIMIT 1")
self.assertTrue(qry.exec_())
self.assertTrue(qry.first())
self.assertEqual(str(qry.value(0)), "")
def cargarFicheroEnBD(self, nombre: str, contenido: str,
log: "QtWidgets.QTextEdit", directorio: str) -> None:
"""Load a file into database."""
if (not qsa.util.isFLDefFile(contenido)
and not nombre.endswith(u".mod")
and not nombre.endswith(u".xpm")
and not nombre.endswith(u".signatures")
and not nombre.endswith(u".checksum")
and not nombre.endswith(u".certificates")
and not nombre.endswith(u".qs") and not nombre.endswith(u".ar")
and not nombre.endswith(u".py")
and not nombre.endswith(u".kut")):
return
cursorFicheros = qsa.FLSqlCursor(u"flfiles")
cursor = self.cursor()
cursorFicheros.select(qsa.ustr(u"nombre = '", nombre, u"'"))
if not cursorFicheros.first():
if nombre.endswith(u".ar"):
if not self.cargarAr(nombre, contenido, log, directorio):
return
log.append(
qsa.util.translate(u"scripts", u"- Cargando :: ") + nombre)
cursorFicheros.setModeAccess(cursorFicheros.Insert)
cursorFicheros.refreshBuffer()
cursorFicheros.setValueBuffer(u"nombre", nombre)
cursorFicheros.setValueBuffer(u"idmodulo",
cursor.valueBuffer(u"idmodulo"))
cursorFicheros.setValueBuffer(u"sha", qsa.util.sha1(contenido))
cursorFicheros.setValueBuffer(u"contenido", contenido)
cursorFicheros.commitBuffer()
else:
cursorFicheros.setModeAccess(cursorFicheros.Edit)
cursorFicheros.refreshBuffer()
contenidoCopia = cursorFicheros.valueBuffer(u"contenido")
if contenidoCopia != contenido:
log.append(
qsa.util.translate(u"scripts", u"- Actualizando :: ") +
nombre)
cursorFicheros.setModeAccess(cursorFicheros.Insert)
cursorFicheros.refreshBuffer()
d = qsa.Date()
cursorFicheros.setValueBuffer(u"nombre",
nombre + qsa.parseString(d))
cursorFicheros.setValueBuffer(u"idmodulo",
cursor.valueBuffer(u"idmodulo"))
cursorFicheros.setValueBuffer(u"contenido", contenidoCopia)
cursorFicheros.commitBuffer()
log.append(
qsa.util.translate(u"scripts", u"- Backup :: ") + nombre +
qsa.parseString(d))
cursorFicheros.select(qsa.ustr(u"nombre = '", nombre, u"'"))
cursorFicheros.first()
cursorFicheros.setModeAccess(cursorFicheros.Edit)
cursorFicheros.refreshBuffer()
cursorFicheros.setValueBuffer(u"idmodulo",
cursor.valueBuffer(u"idmodulo"))
cursorFicheros.setValueBuffer(u"sha", qsa.util.sha1(contenido))
cursorFicheros.setValueBuffer(u"contenido", contenido)
cursorFicheros.commitBuffer()
if nombre.endswith(u".ar"):
self.cargarAr(nombre, contenido, log, directorio)
def exportarADisco(self, directorio: str) -> None:
"""Export a module to disk."""
if directorio:
tdb_lineas = self.child(u"lineas")
if tdb_lineas is None:
raise Exception("lineas control not found")
curFiles = tdb_lineas.cursor()
cursorModules = qsa.FLSqlCursor(u"flmodules")
cursorAreas = qsa.FLSqlCursor(u"flareas")
if curFiles.size() != 0:
dir = qsa.Dir()
idModulo = self.cursor().valueBuffer(u"idmodulo")
log = self.child(u"log")
if log is None:
raise Exception("Log control not found!.")
log.text = u""
directorio = qsa.Dir.cleanDirPath(
qsa.ustr(directorio, u"/", idModulo))
if not dir.fileExists(directorio):
dir.mkdir(directorio)
if not dir.fileExists(qsa.ustr(directorio, u"/forms")):
dir.mkdir(qsa.ustr(directorio, u"/forms"))
if not dir.fileExists(qsa.ustr(directorio, u"/scripts")):
dir.mkdir(qsa.ustr(directorio, u"/scripts"))
if not dir.fileExists(qsa.ustr(directorio, u"/queries")):
dir.mkdir(qsa.ustr(directorio, u"/queries"))
if not dir.fileExists(qsa.ustr(directorio, u"/tables")):
dir.mkdir(qsa.ustr(directorio, u"/tables"))
if not dir.fileExists(qsa.ustr(directorio, u"/reports")):
dir.mkdir(qsa.ustr(directorio, u"/reports"))
if not dir.fileExists(qsa.ustr(directorio, u"/translations")):
dir.mkdir(qsa.ustr(directorio, u"/translations"))
curFiles.first()
file = None
tipo = None
contenido = ""
self.setDisabled(True)
s01_dowhile_1stloop = True
while s01_dowhile_1stloop or curFiles.next():
s01_dowhile_1stloop = False
file = curFiles.valueBuffer(u"nombre")
tipo = self.tipoDeFichero(file)
contenido = curFiles.valueBuffer(u"contenido")
if not contenido == "":
s01_when = tipo
s01_do_work, s01_work_done = False, False
if s01_when == u".xml":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".mod":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".xpm":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".signatures":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".certificates":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".checksum":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(u"ISO-8859-1",
qsa.ustr(directorio, u"/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".ui":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/forms/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".qs":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/scripts/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".py":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"UTF-8",
qsa.ustr(directorio, u"/scripts/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".qry":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/queries/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".mtd":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/tables/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".kut":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"UTF-8",
qsa.ustr(directorio, u"/reports/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if s01_when == u".ts":
s01_do_work, s01_work_done = True, True
if s01_do_work:
qsa.sys.write(
u"UTF-8",
qsa.ustr(directorio, u"/translations/", file),
contenido)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Exportando ", file, u".")))
s01_do_work = False # BREAK
if not s01_work_done:
s01_do_work, s01_work_done = True, True
if s01_do_work:
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(u"* Omitiendo ", file, u".")))
qsa.sys.processEvents()
cursorModules.select(qsa.ustr(u"idmodulo = '", idModulo, u"'"))
if cursorModules.first():
cursorAreas.select(
qsa.ustr(u"idarea = '",
cursorModules.valueBuffer(u"idarea"), u"'"))
cursorAreas.first()
areaName = cursorAreas.valueBuffer(u"descripcion")
if not qsa.FileStatic.exists(
qsa.ustr(directorio, u"/",
cursorModules.valueBuffer(u"idmodulo"),
u".xpm")):
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/",
cursorModules.valueBuffer(u"idmodulo"),
u".xpm"),
cursorModules.valueBuffer(u"icono"),
)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(
u"* Exportando ",
cursorModules.valueBuffer(u"idmodulo"),
u".xpm (Regenerado).",
),
))
if not qsa.FileStatic.exists(
qsa.ustr(directorio, u"/",
cursorModules.valueBuffer(u"idmodulo"),
u".mod")):
contenido = qsa.ustr(
u"<!DOCTYPE MODULE>\n<MODULE>\n<name>",
cursorModules.valueBuffer(u"idmodulo"),
u'</name>\n<alias>QT_TRANSLATE_NOOP("FLWidgetApplication","',
cursorModules.valueBuffer(u"descripcion"),
u'")</alias>\n<area>',
cursorModules.valueBuffer(u"idarea"),
u'</area>\n<areaname>QT_TRANSLATE_NOOP("FLWidgetApplication","',
areaName,
u'")</areaname>\n<version>',
cursorModules.valueBuffer(u"version"),
u"</version>\n<icon>",
cursorModules.valueBuffer(u"idmodulo"),
u".xpm</icon>\n<flversion>",
cursorModules.valueBuffer(u"version"),
u"</flversion>\n<description>",
cursorModules.valueBuffer(u"idmodulo"),
u"</description>\n</MODULE>",
)
qsa.sys.write(
u"ISO-8859-1",
qsa.ustr(directorio, u"/",
cursorModules.valueBuffer(u"idmodulo"),
u".mod"),
contenido,
)
log.append(
qsa.util.translate(
u"scripts",
qsa.ustr(
u"* Generando ",
cursorModules.valueBuffer(u"idmodulo"),
u".mod (Regenerado).",
),
))
self.setDisabled(False)
log.append(
qsa.util.translate(u"scripts",
u"* Exportación finalizada."))
def test_basic_4(self) -> None:
"""Test basic test 4."""
from pineboolib.qsa import qsa
from pineboolib import application
from pineboolib.application.metadata import pntablemetadata, pnfieldmetadata
import os
qsa_sys = qsa.sys
path = fixture_path("principal.eneboopkg")
self.assertTrue(os.path.exists(path))
qsa_sys.loadModules(path, False)
widget = qsa.from_project("flfactppal")
widget.iface.valoresIniciales()
cur_clientes = qsa.FLSqlCursor("clientes")
cur_clientes.setModeAccess(cur_clientes.Insert)
cur_clientes.refreshBuffer()
# cur_clientes.setValueBuffer("codigo", "000001")
cur_clientes.setValueBuffer("nombre", "cliente de prueba")
cur_clientes.setValueBuffer("cifnif", "01234567H")
cur_clientes.setValueBuffer("codserie", "A")
self.assertTrue(cur_clientes.commitBuffer())
cur_clientes.commit()
cur_clientes.conn().doTransaction(cur_clientes)
mtd_tareas = pntablemetadata.PNTableMetaData("tareas")
field_01 = pnfieldmetadata.PNFieldMetaData(
"idtarea",
"Id",
False,
True,
"serial",
0,
True,
True,
True,
0,
0,
True,
True,
False,
None,
False,
False,
False,
True,
False,
)
field_02 = pnfieldmetadata.PNFieldMetaData(
"nombre",
"Nombre",
False,
False,
"string",
10,
False,
True,
True,
0,
0,
False,
False,
False,
None,
False,
False,
True,
False,
False,
)
field_03 = pnfieldmetadata.PNFieldMetaData(
"fechaini",
"Fecha Inicial",
True,
False,
"date",
0,
False,
True,
True,
0,
0,
False,
False,
False,
None,
False,
False,
True,
False,
False,
)
field_04 = pnfieldmetadata.PNFieldMetaData(
"fechafinal",
"Fecha Final",
True,
False,
"date",
0,
False,
True,
True,
0,
0,
False,
False,
False,
None,
False,
False,
True,
False,
False,
)
mtd_tareas.addFieldMD(field_01)
mtd_tareas.addFieldMD(field_02)
mtd_tareas.addFieldMD(field_03)
mtd_tareas.addFieldMD(field_04)
self.assertEqual(mtd_tareas.fieldListArray(False),
["idtarea", "nombre", "fechaini", "fechafinal"])
application.PROJECT.conn_manager.manager(
).cache_metadata_["tareas"] = mtd_tareas
application.PROJECT.conn_manager.manager().createTable("tareas")
self.assertTrue(
application.PROJECT.conn_manager.manager().existsTable("tareas"))
cur_tareas = qsa.FLSqlCursor("tareas")
self.assertEqual(
cur_tareas.metadata().fieldListArray(False),
["idtarea", "nombre", "fechaini", "fechafinal"],
)
cur_tareas.setModeAccess(cur_tareas.Insert)
cur_tareas.refreshBuffer()
# cur_tareas.setValueBuffer("idtarea", 1)
cur_tareas.setValueBuffer("nombre", "prueba1")
self.assertTrue(cur_tareas.commitBuffer())
cur_tareas.setModeAccess(cur_tareas.Insert)
cur_tareas.refreshBuffer()
# cur_tareas.setValueBuffer("idtarea", 2)
cur_tareas.setValueBuffer("nombre", "prueba2")
cur_tareas.setValueBuffer("fechaini", str(qsa.Date()))
cur_tareas.setValueBuffer("fechafinal", str(qsa.Date()))
self.assertTrue(cur_tareas.commitBuffer())
cur_tareas.setModeAccess(cur_tareas.Insert)
cur_tareas.refreshBuffer()
# cur_tareas.setValueBuffer("idtarea", 3)
cur_tareas.setValueBuffer("nombre", "prueba3")
cur_tareas.setValueBuffer("fechaini", str(qsa.Date()))
cur_tareas.setValueBuffer("fechafinal", str(qsa.Date()))
self.assertTrue(cur_tareas.commitBuffer())
cur_tareas.setModeAccess(cur_tareas.Insert)
cur_tareas.refreshBuffer()
cur_tareas.setValueBuffer("nombre", "prueba4")
cur_tareas.setValueBuffer("fechaini", str(qsa.Date()))
self.assertTrue(cur_tareas.commitBuffer())
cur_tareas.setModeAccess(cur_tareas.Insert)
cur_tareas.refreshBuffer()
# cur_tareas.setValueBuffer("idtarea", 3)
cur_tareas.setValueBuffer("nombre", "prueba5")
cur_tareas.setValueBuffer("fechafinal", str(qsa.Date()))
self.assertTrue(cur_tareas.commitBuffer())
cur_tareas.commit()
qry = qsa.FLSqlQuery()
qry.setSelect("idtarea,nombre,fechaini,fechafinal")
qry.setFrom("tareas")
qry.setWhere("1=1")
qry.setOrderBy("idtarea")
self.assertTrue(qry.exec_())
self.assertTrue(qry.first())
self.assertEqual(qry.value("fechaini"), "")
self.assertEqual(qry.value("fechafinal"), "")
self.assertTrue(qry.next())
self.assertNotEqual(qry.value("fechaini"), "")
self.assertNotEqual(qry.value("fechafinal"), "")
self.assertTrue(qry.next())
self.assertNotEqual(qry.value("fechaini"), "")
self.assertNotEqual(qry.value("fechafinal"), "")
self.assertTrue(qry.next())
self.assertNotEqual(qry.value("fechaini"), "")
self.assertEqual(qry.value("fechafinal"), "")
self.assertTrue(qry.next())
self.assertEqual(qry.value("fechaini"), "")
self.assertNotEqual(qry.value("fechafinal"), "")
def cargarModulo(self, nombre_fichero: str) -> bool:
"""Load modules."""
util = qsa.FLUtil()
fichero = qsa.File(nombre_fichero, "iso-8859-15")
modulo = None
descripcion = None
area = None
desArea = None
version = None
nombreIcono = None
# versionMinimaFL = None
dependencias = qsa.Array()
fichero.open(qsa.File.ReadOnly)
f = fichero.read()
xmlModule = qsa.FLDomDocument()
if xmlModule.setContent(f):
nodeModule = xmlModule.namedItem(u"MODULE")
if not nodeModule:
qsa.MessageBox.critical(
util.translate(u"scripts",
u"Error en la carga del fichero xml .mod"),
qsa.MessageBox.Ok,
qsa.MessageBox.NoButton,
)
modulo = nodeModule.namedItem(u"name").toElement().text()
descripcion = nodeModule.namedItem(u"alias").toElement().text()
area = nodeModule.namedItem(u"area").toElement().text()
desArea = nodeModule.namedItem(u"areaname").toElement().text()
version = nodeModule.namedItem(u"version").toElement().text()
nombreIcono = nodeModule.namedItem(u"icon").toElement().text()
# if nodeModule.namedItem(u"flversion"):
# versionMinimaFL = nodeModule.namedItem(u"flversion").toElement().text()
if nodeModule.namedItem(u"dependencies"):
nodeDepend = xmlModule.elementsByTagName(u"dependency")
i = 0
while_pass = True
while i < len(nodeDepend):
if not while_pass:
i += 1
while_pass = True
continue
while_pass = False
dependencias[i] = nodeDepend.item(i).toElement().text()
i += 1
while_pass = True
try:
i < len(nodeDepend)
except Exception:
break
else:
if not isinstance(f, str):
raise Exception("data must be str, not bytes!!")
aF = f.split(u"\n")
modulo = self.dameValor(aF[0])
descripcion = self.dameValor(aF[1])
area = self.dameValor(aF[2]) or ""
desArea = self.dameValor(aF[3])
version = self.dameValor(aF[4])
nombreIcono = self.dameValor(aF[5])
descripcion = self.traducirCadena(descripcion or "", fichero.path
or "", modulo or "")
desArea = self.traducirCadena(desArea or "", fichero.path or "", modulo
or "")
fichIcono = qsa.File(qsa.ustr(fichero.path, u"/", nombreIcono))
fichIcono.open(qsa.File.ReadOnly)
icono = fichIcono.read()
if not util.sqlSelect(u"flareas", u"idarea",
qsa.ustr(u"idarea = '", area, u"'")):
if not util.sqlInsert(u"flareas", u"idarea,descripcion",
qsa.ustr(area, u",", desArea)):
qsa.MessageBox.warning(
util.translate(u"scripts", u"Error al crear el área:\n") +
area,
qsa.MessageBox.Ok,
qsa.MessageBox.NoButton,
)
return False
recargar = util.sqlSelect(u"flmodules", u"idmodulo",
qsa.ustr(u"idmodulo = '", modulo, u"'"))
curModulo = qsa.FLSqlCursor(u"flmodules")
if recargar:
# WITH_START
curModulo.select(qsa.ustr(u"idmodulo = '", modulo, u"'"))
curModulo.first()
curModulo.setModeAccess(curModulo.Edit)
# WITH_END
else:
curModulo.setModeAccess(curModulo.Insert)
# WITH_START
curModulo.refreshBuffer()
curModulo.setValueBuffer(u"idmodulo", modulo)
curModulo.setValueBuffer(u"descripcion", descripcion)
curModulo.setValueBuffer(u"idarea", area)
curModulo.setValueBuffer(u"version", version)
curModulo.setValueBuffer(u"icono", icono)
curModulo.commitBuffer()
# WITH_END
# curSeleccion = qsa.FLSqlCursor(u"flmodules")
curModulo.setMainFilter(qsa.ustr(u"idmodulo = '", modulo, u"'"))
curModulo.editRecord(False)
qsa.from_project("formRecordflmodules").cargarDeDisco(
qsa.ustr(fichero.path, u"/"), False)
qsa.from_project("formRecordflmodules").accept()
setting = "scripts/sys/modLastModule_%s" % qsa.sys.nameBD()
nombre_fichero = "%s" % os.path.abspath(nombre_fichero)
qsa.util.writeSettingEntry(setting, nombre_fichero)
qsa.sys.processEvents()
return True