def testAplicarParches(self):
"Aplica todos los parches presentes y verificar que ninguno este aplicado"
parches = ModeladorDao.getParches(1)
preaplicados = []
parchesFallidos = []
for parche in parches:
if ModeladorDao.verificarParche(
parche["archivoParche"])["aplicado"]:
preaplicados.append(parche["archivoParche"])
else:
#el parche "" debe fallar obligatoriamente. los demas NO
resultado = ModeladorDao.aplicarParche(parche["archivoParche"])
if resultado != "1" and parche[
"archivoParche"] != "parche1.sql":
parchesFallidos.append(parche["archivoParche"])
elif resultado == "1" and parche[
"archivoParche"] == "parche1.sql":
parchesFallidos.append(parche["archivoParche"])
if len(preaplicados) > 0:
self.fail("Los parches %s estaban aplicados de antemano" %
str(preaplicados))
if len(parchesFallidos) > 0:
self.fail("Los parches %s fallaron al aplicarse" %
str(parchesFallidos))
parches = ModeladorDao.getParches(0)
# recordar que solo el parche "parche1.sql" no debio aplicarse
if len(parches) > 1:
self.fail("Los parches %s no fueron aplicados" % str(parches))
def testValidarModelo(self):
modelos = ModeladorDao.getModelos()
#primer modelo estara incompleto
modelo = modelos[0]
validaciones = ModeladorDao.validarModelo(modelo['idModelo'])
if len(validaciones) == 0:
self.fail("se esperaba validaciones")
def testGeneradoresEntidad(self):
modelos = ModeladorDao.getModelos()
modelo = modelos[len(modelos) - 1]
generadores = ModeladorDao.getGeneradoresByModelo(modelo["idModelo"])
if generadores is None or len(generadores) == 0:
self.fail("error recuperando Generadores para Entidades")
for generador in generadores:
self.testGenerador(generador, modelo)
generador = ModeladorDao.getModeloGenerador(
modelo["idModelo"], generadores[0]["idGenerador"])
if generador is None:
self.fail("error recuperando generador individual")
self.testGenerador(generador, modelo)
def server_crear_objeto_hijo_html ():
salida = {}
try:
nombre = request.forms.get("nombre")
idJerarquia = request.forms.get("idJerarquia")
idObjetoPadre = int(request.forms.get("idObjetoPadre"))
objetoModelo = ModeladorDao.ObjetoModeloDao().nuevoDiccionario()
objetoModelo["idObjetoPadre"] = idObjetoPadre
objetoModelo["nombre"] = nombre
objetoModelo["idJerarquia"] = idJerarquia
salida = ModeladorDao.crearObjetoHijo( objetoModelo )
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def generarModelo(modelo , archivo):
print("inicia GeneradorERScriptSql")
try:
fileName = ( "%s%s" % (modelo["nombre"],modelo["__generador"]["extension"]) )
raiz = ModeladorDao.getRaizModelo(modelo["idModelo"])
entidades = ModeladorDao.getObjetosModeloByPadre( raiz["idObjeto"] , "Entidades" )
archivo.write("import xpdbdd\n")
for entidad in entidades:
atributosEntidad = ModeladorDao.getDiccionarioAtributosByObjetoModelo( entidad["idObjeto"] )
namedQueries = ModeladorDao.getObjetosModeloByPadre(entidad["idObjeto"],"NamedQueries")
campos = ModeladorDao.getObjetosModeloByPadre(entidad["idObjeto"],"Campos")
archivo.write("\nclass %sDao(xpdbdd.DaoBase):\n def __init__(self):" % entidad["nombre"] )
archivo.write("\n metamodelo={\"nombreTabla\":\"%s\",\"propiedades\":[],\"namedQueries\":[]}" % atributosEntidad["nombreTabla"] )
for campo in campos:
atributosCampo = ModeladorDao. getDiccionarioAtributosByObjetoModelo( campo["idObjeto"] )
tipo = getTipo(atributosCampo)
tamano = getCantidad(atributosCampo,"tamano")
opcional = "0"
if parseBoolean(atributosCampo["obligatorio"]) == "0":
opcional = "1"
archivo.write("\n metamodelo[\"propiedades\"].append({\"nombre\":\"%s\",\"nombreCampo\":\"%s\",\"incremental\":%s,\"pk\":%s,\"tipo\":%s,\"tamano\":%s,\"insert\":%s,\"update\":%s,\"opcional\":%s})" % ( campo["nombre"], atributosCampo["nombreCampo"] , parseBoolean(atributosCampo["incremental"]) , parseBoolean(atributosCampo["pk"]) , tipo , tamano , parseBoolean(atributosCampo["insert"]) , parseBoolean(atributosCampo["update"]) , opcional ) )
for namedQuery in namedQueries:
camposWhere = ModeladorDao.getObjetosModeloByPadre(namedQuery["idObjeto"],"camposWhere")
namedQuery["camposWhere"] = camposWhere
camposOrderBy = ModeladorDao.getObjetosModeloByPadre(namedQuery["idObjeto"],"camposOrderBy")
archivo.write("\n metamodelo[\"namedQueries\"].append({\"nombre\":\"%s\",\"whereClause\":[%s],\"orderBy\":[%s]})" % ( namedQuery["nombre"] , getListaCampos(camposWhere) , getListaCampos(camposOrderBy) ))
archivo.write( "\n self.setMetamodelo (metamodelo)" )
for namedQuery in namedQueries:
camposWhere = namedQuery["camposWhere"]
archivo.write("\n \n def %s (self, conexion" % namedQuery["nombre"] )
for campoWhere in camposWhere:
archivo.write(", %s" % campoWhere["nombre"])
archivo.write("):")
archivo.write("\n return self.getNamedQuery(conexion,\"%s\", {" % namedQuery["nombre"] )
primercampo = True
for campoWhere in camposWhere:
if not (primercampo):
archivo.write(",")
archivo.write("\"%s\":%s" % ( campoWhere["nombre"] , campoWhere["nombre"] ))
primercampo = False
archivo.write("} ) ")
archivo.write("\n")
archivo.flush()
resultado = {"fileName":fileName,"mimeType":modelo["__generador"]["mimeType"]}
return resultado
except (Exception) as ex:
print(repr(ex))
return {"error":repr(ex)}
def server_lista_modelos_html ():
salida = ("")
try:
lista = ModeladorDao.getModelos()
salida = { 'registros' : lista }
except (Exception) as ex:
salida = {'error':repr(ex)}
print(repr(ex))
return salida
def testGenerarScriptSql(self):
"generacion script"
archivo = open(config.APP_ROOT + '/test/Seguridad.txt', 'r')
strImport = archivo.read()
#print("JSON "+ strImport[:150])
jsonModelo = json.loads(strImport)
idModeloImportado = ModeladorDao.importarModelo(jsonModelo)
generado = ModeladorDao.generarModelo(idModeloImportado, 'SCRIPT_SQL')
#print("TESTGENERARSCRIPTSQL " + repr(generado))
if generado is None:
self.fail("respuesta None ")
if 'error' in generado:
self.fail("respuesta con error " + generado['error'])
if not ('archivos' in generado):
self.fail("respuesta no contiene lista de archivos")
if len(generado['archivos']) == 0:
self.fail("no se generaron archivos")
if not ('create table' in generado['archivos'][0]['contenido']):
self.fail("contenido de archivo no esperado")
def server_validar_modelo ():
salida = {}
try:
idModelo = int(request.forms.get("idModelo"))
salida = {'lista' : ModeladorDao.validarModelo( idModelo ) }
print(str(salida))
except (Exception) as ex:
salida = {'error': repr(ex) }
print(repr(ex))
return salida
def server_verificar_parche_html ():
salida = {}
try:
archivoParche = request.forms.get("archivoParche")
salida = ModeladorDao.verificarParche( archivoParche )
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_catalogo_valor_html ():
salida = {}
try:
idModelo = int(request.forms.get("idModelo"))
salida = ModeladorDao.getCatalogoByModelo( idModelo )
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_raiz_modelo_html ():
salida = {}
try:
idModelo = int(request.forms.get("idModelo"))
salida = ModeladorDao.getRaizModelo( idModelo )
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_atributos_objeto_html ():
salida = {}
try:
idObjeto = int(request.forms.get("idObjeto"))
salida = ModeladorDao.getAtributosByObjetoModelo( idObjeto )
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_parches_html ():
salida = {}
try:
incluirAplicados = int(request.forms.get("incluirAplicados"))
salida = {"__lista":ModeladorDao.getParches( incluirAplicados ) }
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_generadores_html ():
salida = {}
try:
idModelo = int(request.forms.get("idModelo"))
salida = {"lista":ModeladorDao.getGeneradoresByModelo( idModelo ) }
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_objetos_by_modelo_tipo_html ():
salida = {}
try:
idModelo = int(request.forms.get("idModelo"))
idTipoMetamodelo = request.forms.get("idTipoMetamodelo")
salida = {"lista":ModeladorDao.getObjetosModeloByModeloTipo( idModelo ,idTipoMetamodelo ) }
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_get_objetos_by_padre_html ():
salida = {}
try:
idObjeto = int(request.forms.get("idObjeto"))
idJerarquia = request.forms.get("idJerarquia")
salida = {"lista":ModeladorDao.getObjetosModeloByPadre( idObjeto ,idJerarquia ) }
print(str(salida))
except (Exception) as ex:
salida = {}
print(repr(ex))
return salida
def server_aplicar_parche_html ():
salida = ("")
try:
archivoParche = request.forms.get("archivoParche")
salida = ModeladorDao.aplicarParche( archivoParche )
if config.DEBUG_MODE:
print(salida)
except (Exception) as ex:
salida = (repr(ex))
print(repr(ex))
return salida
def server_eliminar_objeto_html ():
salida = ("")
try:
idObjeto = int(request.forms.get("idObjeto"))
salida = str(ModeladorDao.eliminarObjeto( idObjeto , None ) )
if config.DEBUG_MODE:
print("RESULTADO ELIMINAR: %s"%salida)
except (Exception) as ex:
salida = (repr(ex))
print(repr(ex))
return salida
def server_crear_modelo_html ():
salida = ("")
try:
nombreModelo = request.forms.get("nombreModelo")
idMetamodelo = int(request.forms.get("idMetamodelo"))
modelo = ModeladorDao.crearModelo({"idMetamodelo":idMetamodelo,"nombre":nombreModelo})
salida = modelo
except (Exception) as ex:
salida = ("")
print(repr(ex))
return salida
def testGetCatalogos(self):
lista = ModeladorDao.getCatalogoByModelo(1)
if len(lista) == 0:
self.fail("no se pudo recuperar catalogo")
if not ('BOOLEAN' in lista):
self.fail("falta catslogo boolean")
if not ('TIPO_PRIM' in lista):
self.fail("falta catslogo TIPOS PRIMITIVOS")
if len(lista['BOOLEAN']) < 2:
self.fail("catslogo boolean incompleto")
if len(lista['TIPO_PRIM']) < 10:
self.fail("catslogo tipos primitivos incompleto")
def server_regenerar_metamodelo_html ():
salida = ("")
try:
idMetamodelo = int(request.forms.get("idMetamodelo"))
if idMetamodelo is None:
raise Exception ("Ingreso no autorizado")
if not ModeladorDao.regenerarMetamodelo():
raise Exception ("Error en Inicializacion")
salida = str("Inicializacion Exitosa")
except (Exception) as ex:
salida = ( repr(ex) )
return salida
def server_mover_objeto_html ():
salida = ("")
try:
idObjeto = int(request.forms.get("idObjeto"))
moverArriba = int(request.forms.get("moverArriba"))
salida = str(ModeladorDao.moverObjeto( idObjeto , moverArriba ) )
if config.DEBUG_MODE:
print("RESULTADO Mover: %s"%salida)
except (Exception) as ex:
salida = (repr(ex))
print(repr(ex))
return salida
def testActualizarAtributosObjeto(self):
modelos = ModeladorDao.getModelos()
modelo = modelos[len(modelos) - 1]
raizModelo = ModeladorDao.getRaizModelo(modelo["idModelo"])
objetoModelo = ModeladorDao.getObjetosModeloByPadre(
raizModelo["idObjeto"], "Entidades")[0]
objetoModelo = ModeladorDao.getAtributosByObjetoModelo(
objetoModelo["idObjeto"])
#print (str (objetoModelo))
objetoModelo["nombre"] = ("ABC")
objetoModelo["descripcion"] = ("CDE")
objetoModelo["__atributos"] = objetoModelo["_atributos"]
objetoModelo["__atributos"][0]["valor"] = ("ABC")
objetoModelo1 = ModeladorDao.actualizarAtributosObjeto(
objetoModelo, None)
if objetoModelo1["__errorCode"] != 0:
self.fail("error act atributos")
objetoModelo1 = ModeladorDao.getAtributosByObjetoModelo(
objetoModelo["idObjeto"])
if objetoModelo["nombre"] != objetoModelo1["nombre"]:
self.fail("error al actualizar nombre")
if objetoModelo["descripcion"] != objetoModelo1["descripcion"]:
self.fail("error al actualizar descripcion")
if objetoModelo["_atributos"][0]["valor"] != objetoModelo1[
"_atributos"][0]["valor"]:
self.fail("error al actualizar atributo")
def server_exportar_modelo_html ():
salida = ("")
try:
idModelo = int(request.forms.get("idModelo"))
bandera_descargar = request.forms.get("descargar")
nombreArchivo = request.forms.get("path")
print("exportando modelo %d" % idModelo)
modelo = ModeladorDao.exportarModelo(idModelo,nombreArchivo)
salida = json.dumps( modelo, sort_keys = False, indent = 2, separators = (',',':') )
if config.DOWNLOAD_ENABLED and bandera_descargar == '1':
response.set_header("Content-Type","text/txt")
response.add_header("content-disposition","attachment ;filename=%s.txt" % modelo["nombre"] );
if config.DEBUG_MODE:
print(salida)
except (Exception) as ex:
salida = ("Error al exportar modelo: "+repr(ex))
print(repr(ex))
return salida
def server_generar_modelo_html ():
archivoSalida = {}
try:
print("inicia generarModelo")
if config.DEBUG_MODE:
print (request.forms.get("idModelo"))
idModelo = int(request.forms.get("idModelo"))
idGenerador = request.forms.get("idGenerador")
archivoSalida = ModeladorDao.generarModelo(idModelo, idGenerador)
#archivoSalida = GeneradorModelo.generarModelo(idModelo,idGenerador)
#print (str(archivoSalida))
return archivoSalida
# return static_file( archivoSalida["fileName"] , root=config.TEMP_ROOT, mimetype= archivoSalida["mimeType"] )
except (Exception) as ex:
print(repr(ex))
return {"error":"Error al recuperar modelo"}
def server_importar_modelo_html ():
salida = ("")
strImport =("")
fileImport = None
try:
nombreArchivo = request.forms.get("nombreArchivo")
if nombreArchivo is None:
fileImport = request.files.get("modeloImportado").file
strImport = fileImport.read().decode("utf-8")
else:
fileImport = open( "%s/%s"%(config.FS_ROOT,nombreArchivo) ,'r')
strImport = fileImport.read()
jsonModelo = json.loads(strImport)
salida = str(ModeladorDao.importarModelo( jsonModelo ) )
except (Exception) as ex:
salida = (repr(ex) + "*" +strImport )
print(repr(ex))
finally:
if not(fileImport is None):
fileImport.close()
fileImport = None
return salida
def testExportarImportar(self):
"exporta el primer modelo para importarlo"
nombreArchivo = ("Documents/export.txt")
modelos = ModeladorDao.getModelos()
modelo = modelos[len(modelos) - 1]
jsonModelo = ModeladorDao.exportarModelo(modelo["idModelo"],
nombreArchivo)
#print ("Modelo inicial\n%s\n" % str(jsonModelo))
objetosExportados = len(
ModeladorDao.getObjetosByModelo(modelo["idModelo"]))
idModeloImportado = ModeladorDao.importarModelo(jsonModelo)
jsonModelo = ModeladorDao.exportarModelo(idModeloImportado)
#print ("Modelo importado\n%s\n" % str(jsonModelo))
objetosImportados = len(
ModeladorDao.getObjetosByModelo(idModeloImportado))
if objetosImportados != objetosExportados:
self.fail("Importacion o exportacion fallaron")
def testCrearModeloValido(self):
conteo = len(ModeladorDao.getModelos())
#if conteo!=0:
# self.fail("no se puede recuperar modelos creado por default")
modeloDao = ModeladorDao.ModeloDao()
modelo = modeloDao.nuevoDiccionario()
modelo["idMetamodelo"] = 1
modelo["nombre"] = ("ModeloDePrueba")
modelo = ModeladorDao.crearModelo(modelo)
if modelo["idModelo"] is None or modelo["idModelo"] == 0:
self.fail("no se pudo obtener id de Modelo")
#print ("MODELO CREADO %s"%str (modelo))
conteo1 = len(ModeladorDao.getModelos())
if conteo1 != (conteo + 1):
self.fail("creación de modelo no ha alterado contador")
raizModelo = ModeladorDao.getRaizModelo(modelo["idModelo"])
if raizModelo is None or raizModelo["idObjeto"] != modelo[
"idObjetoRaiz"]:
self.fail("no se recuperó objetoRaiz")
modelos = ModeladorDao.getModelos()
if len(modelos) <= 0:
self.fail("No se puede consultar modelos")
def testRegenerarMetamodelo(self):
if not (ModeladorDao.regenerarMetamodelo()):
self.fail("Error en Regeneracion de metamodelo")
def testGetMetamodelos(self):
lista = ModeladorDao.getMetamodelos()
if len(lista) == 0:
self.fail("no se pudo recuperar metamodelos")