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_form_globals(self) -> None:
"""Test form acls globals."""
from pineboolib.qsa import qsa
from pineboolib import application
import importlib
sys_type = systype.SysType()
sys_type.installACL("tercera")
acl = pnaccesscontrollists.PNAccessControlLists()
acl.init()
flapplication.aqApp.set_acl(acl)
project = application.PROJECT
project.main_form = importlib.import_module(
"pineboolib.plugins.mainform.eneboo.eneboo")
project.main_window = getattr(project.main_form, "mainWindow", None)
main_form_ = getattr(project.main_form, "MainForm", None)
self.assertTrue(main_form_)
self.main_w = main_form_()
self.main_w.initScript()
self.main_w.show()
self.assertTrue(self.main_w)
form = qsa.from_project("formflmodules")
control_1 = form.child("tableDBRecords")
self.assertTrue(control_1)
self.assertFalse(control_1.isEnabled())
def cargarModulo(self, nombre_fichero: str) -> bool:
"""Load a module and return True if loaded."""
util = qsa.FLUtil()
if util.getOS() == u"WIN32":
nombre_fichero = nombre_fichero[0 : len(nombre_fichero) - 1]
return qsa.from_project("formflreloadlast").cargarModulo(nombre_fichero)
def cargarAr(self, nombre: str, contenido: str, log: "QtWidgets.QTextEdit",
directorio: str) -> bool:
"""Load AR reports."""
if not qsa.sys.isLoadedModule(u"flar2kut"):
return False
if qsa.util.readSettingEntry(u"scripts/sys/conversionAr") != u"true":
return False
log.append(
qsa.util.translate(u"scripts", u"Convirtiendo %s a kut") %
(str(nombre)))
contenido = qsa.sys.toUnicode(contenido, u"UTF-8")
contenido = qsa.from_project("flar2kut").iface.pub_ar2kut(contenido)
nombre = qsa.ustr(qsa.parseString(nombre)[0:len(nombre) - 3], u".kut")
if contenido:
localEnc = qsa.util.readSettingEntry(
u"scripts/sys/conversionArENC")
if not localEnc:
localEnc = u"ISO-8859-15"
contenido = qsa.sys.fromUnicode(contenido, localEnc)
self.cargarFicheroEnBD(nombre, contenido, log, directorio)
log.append(
qsa.util.translate(u"scripts", u"Volcando a disco ") + nombre)
qsa.FileStatic.write(
qsa.Dir.cleanDirPath(qsa.ustr(directorio, u"/", nombre)),
contenido)
else:
log.append(qsa.util.translate(u"scripts", u"Error de conversión"))
return False
return True
def receive_json(self, content, **kwargs):
# self.send_json(content)
# TODO groupSend, channelSend, api
user = self.scope["user"]
print(content)
if "token" in self.scope:
userid = qsa.FLUtil.quickSqlSelect(
'authtoken_token', 'user_id',
'key = \'' + str(self.scope["token"]) + '\'')
user = qsa.FLUtil.quickSqlSelect('auth_user', 'username',
'id = \'' + str(userid) + '\'')
if content["type"] == "legacy":
prefix = content["prefix"]
params = content["params"] if "params" in content else {
"params": {
"pk": content["pk"]
} if "pk" in content else False
}
action = content["action"] if "action" in content else None
try:
obj = qsa.from_project("formAPI").entry_point(
"websocket", prefix, user, params, action)
async_to_sync(self.channel_layer.group_send)(
self.room_group_name, {
"type": "send.msg",
"content": obj,
})
except Exception as e:
print("_______________________")
print(e)
self.send_json({"error": content})
def test_form_flacos(self) -> None:
"""Test form acls from flacos."""
from pineboolib.qsa import qsa
sys_type = systype.SysType()
sys_type.installACL("tercera")
acl = pnaccesscontrollists.PNAccessControlLists()
acl.init()
flapplication.aqApp.set_acl(acl)
button_1 = qsa.from_project("formRecordflmodules").child(
"botonExportar") # r-
button_2 = qsa.from_project("formRecordflmodules").child(
"botonCargar") # --
self.assertTrue(button_2.isHidden()) # not visible
self.assertFalse(button_2.isEnabled()) # not enabled
self.assertFalse(button_1.isHidden()) # visible
self.assertFalse(button_1.isEnabled()) # not enabled
def test_script_overload(self) -> None:
"""Test script overload loader."""
from pineboolib.qsa import qsa
from pineboolib import application
self.assertEqual(qsa.from_project("sys").saluda(), "Hola!")
action = application.PROJECT.actions["sys"]
script = application.load_script.load_script("sys.qs", action)
self.assertEqual(script.FormInternalObj().saluda(), "Hola!")
def init(self) -> None:
"""Init function."""
settings = qsa.AQSettings()
app_ = qsa.aqApp
if not app_:
return
flfactppal = qsa.SysType().isLoadedModule("flfactppal")
if flfactppal is True:
try:
codEjercicio = qsa.from_project("flfactppal").iface.pub_ejercicioActual()
except Exception as e:
logger.error(
"Module flfactppal was loaded but not able to execute <flfactppal.iface.pub_ejercicioActual()>"
)
logger.error(
"... this usually means that flfactppal has failed translation to python"
)
logger.exception(e)
codEjercicio = None
if codEjercicio:
util = qsa.FLUtil()
nombreEjercicio = util.sqlSelect(
u"ejercicios", u"nombre", qsa.ustr(u"codejercicio='", codEjercicio, u"'")
)
if qsa.AQUtil.sqlSelect(u"flsettings", u"valor", u"flkey='PosInfo'") == "True":
texto = ""
if nombreEjercicio:
texto = qsa.ustr(u"[ ", nombreEjercicio, u" ]")
texto = qsa.ustr(
texto,
u" [ ",
app_.db().driverNameToDriverAlias(app_.db().driverName()),
u" ] * [ ",
qsa.SysType().nameBD(),
u" ] * [ ",
qsa.SysType().nameUser(),
u" ] ",
)
app_.setCaptionMainWidget(texto)
else:
if nombreEjercicio:
app_.setCaptionMainWidget(nombreEjercicio)
oldApi = settings.readBoolEntry(u"application/oldApi")
if not oldApi:
valor = util.readSettingEntry(u"ebcomportamiento/ebCallFunction")
if valor:
funcion = qsa.Function(valor)
try:
funcion()
except Exception:
qsa.debug(traceback.format_exc())
if settings.readBoolEntry("ebcomportamiento/git_updates_enabled", False):
qsa.sys.AQTimer.singleShot(2000, qsa.SysType.search_git_updates)
def main(self) -> None:
"""Entry function."""
continuar = qsa.MessageBox.warning(
qsa.util.translate(
u"scripts",
u"Antes de cargar un módulo asegúrese de tener una copia de seguridad de todos los datos,\n"
+
"y de que no hay ningun otro usuario conectado a la base de datos mientras se realiza la carga.\n\n¿Desea continuar?",
),
qsa.MessageBox.Yes,
qsa.MessageBox.No,
)
if continuar == qsa.MessageBox.No:
return
nombre_fichero = qsa.FileDialog.getOpenFileName(
u"modfiles(*.mod)",
qsa.util.translate(u"scripts", u"Elegir Fichero"))
if nombre_fichero:
fichero = qsa.File(nombre_fichero)
if not qsa.from_project(
"formRecordflmodules").aceptarLicenciaDelModulo(
qsa.ustr(fichero.path, u"/")):
qsa.MessageBox.critical(
qsa.util.translate(
u"scripts",
u"Imposible cargar el módulo.\nLicencia del módulo no aceptada."
),
qsa.MessageBox.Ok,
)
return
if qsa.from_project("formflreloadlast").cargarModulo(
nombre_fichero):
app_ = qsa.aqApp
if app_ is None:
return
app_.reinit()
def traducirCadena(self, cadena: str, path: str, modulo: str) -> str:
"""Translate a string."""
return qsa.from_project("formflreloadlast").traducirCadena(cadena, path, modulo)
def compararVersiones(self, v1: str, v2: str) -> int:
"""Compare two versions and return the highest."""
return qsa.from_project("formflreloadlast").compararVersiones(v1, v2)
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 test_from_project_2(self) -> None:
"""Test from_project('sys')."""
from pineboolib.qsa import qsa
self.assertTrue(hasattr(qsa.from_project("sys"), "iface"))
def test_basic_5(self) -> None:
"""Basic tests 5."""
from pineboolib.application.database import pnsqlcursor
from pineboolib.qsa import qsa
cursor_6 = pnsqlcursor.PNSqlCursor("flareas")
cursor_6.setModeAccess(cursor_6.Insert)
cursor_6.refreshBuffer()
cursor_6.setValueBuffer("bloqueo", True)
cursor_6.setValueBuffer("idarea", "T")
cursor_6.setValueBuffer("descripcion", "Área de prueba T")
self.assertTrue(cursor_6.commitBuffer())
cursor_qry = pnsqlcursor.PNSqlCursor("fltest2")
self.assertTrue(cursor_qry)
self.assertFalse(cursor_qry.private_cursor.needUpdate())
cursor = pnsqlcursor.PNSqlCursor("fltest")
self.assertFalse(cursor.private_cursor.needUpdate())
self.assertEqual(cursor.primaryKey(), "id")
self.assertEqual(cursor.fieldType("id"), 100)
cursor_qry.setNotGenerateds()
cursor.sort()
self.assertFalse(cursor.fieldType("id2"))
for field in cursor:
self.assertTrue(field)
cursor_2 = pnsqlcursor.PNSqlCursor("flareas")
cursor_2.update(False)
cursor.changeConnection("dbAux")
self.assertEqual(cursor.transactionsOpened(), [])
cursor.db().doTransaction(cursor)
self.assertEqual(cursor.transactionsOpened(), ["1"])
cursor.db().doRollback(cursor)
cursor.setForwardOnly(True)
cursor_3 = pnsqlcursor.PNSqlCursor("flareas")
cursor_3.select()
self.assertTrue(cursor_3.first())
cursor_3.chooseRecord(False)
qsa.from_project("formRecordflareas").reject()
cursor_3.select()
cursor_3.first()
cursor_3.browseRecord(False)
qsa.from_project("formRecordflareas").reject()
cursor_3.select()
cursor_3.first()
cursor_3.editRecord(False)
qsa.from_project("formRecordflareas").reject()
cursor_4 = pnsqlcursor.PNSqlCursor("flareas")
cursor_4.select()
cursor_4.first()
self.assertTrue(cursor_4.selection_pk("T"))
cursor_4.last()
self.assertTrue(cursor_4.selection_pk("T"))
cursor_4.last()
self.assertFalse(cursor_4.selection_pk("J"))
cursor_4.setNull("idarea")
cursor_4.setModeAccess(cursor_4.Insert)
cursor_4.refreshBuffer()
self.assertFalse(cursor_4.checkIntegrity())
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
