/**
* Devuelve la lista de los nombres de todas las clases de modelo de una aplicacion,
* incluso si estan en subdirectorios.
*/
public static function getModelClasses($app)
{
// el directorio del modelo es fijo, pero lo tengo que sacar de una configuracion, no hardcoded aca.
//$apps = PackageNames::getAppNames();
$classNames = array();
$package = "{$app}/model";
// TODO: si hay subdirectorios, devolverlos tambien.
$model_path = YuppConventions::getModelPath($package);
// La aplicacion puede no tener directorio de model
//if (file_exists($model_path))
//{
// $_classNames = FileSystem::getFileNames($model_path, PackageNames::MODEL_FILE_REGEXP, array( PackageNames::MODEL_CLASS_GROUP )); // Todos los php del paquete utils, idem anterior, ahora sin el "utils."
// $classNames = array_merge($classNames, $_classNames);
//}
if (file_exists($model_path)) {
$classNamesRecur = self::getModelClassesRecursive($model_path);
$classNames = array_merge($classNames, $classNamesRecur);
}
// Levanta el directorio y los nombres de las clases.
// Grupo 1 es el nombre de la aplicacion
// Grupo 2 es el nombre de la clase
// TODO: LA REGEXP DEL PAQUETE DE MODELO ME LO DEBERIA DAR UNA CLASE RESPONSABLE DE SABER CUALES SON LAS REGEXPS DE LOS PAQUETES DESTACADOS Y DADO UNA RUTA DE PAQUETES SABER DE QUE TIPO ES (modulos, core, modelo, vistas, acciones, etc.)
// Los nombres estan codificados segun algun estandar (a definir) y se puede sacar el nombre de la clase del nombre del archivo.
// NOMBRES: modelDir/app.ClassName.php
return $classNames;
}
/**
* Devuelve la superclase de $class que genera la tabla donde se guarda $class.
* Si $class es de nivel 1, se retorna $class.
*/
public static function superclassThatGenerateMyTable($class)
{
$parent = get_parent_class($class);
if ($parent === 'PersistentObject') {
return $class;
}
$classTable = YuppConventions::tableName($class);
// Tengo que ir para arriba y ver quien es el ultimo que tiene la tabla
// igual a la mia, antes de llegar a PO o llegar a otro con distinta tabla.
// Chekeo si ya la primer superclase se mapea en una tabla distinta, devuelvo $class.
$superclassTable = YuppConventions::tableName($parent);
if ($classTable != $superclassTable) {
return $class;
}
// $class y $parent se mapean en la misma tabla.
$prevClassToIterate = $parent;
$classToIterate = get_parent_class($parent);
// Puede ser PO.
$found = false;
while (!$found && $classToIterate !== 'PersistentObject') {
$superclassTable = YuppConventions::tableName($classToIterate);
if ($classTable != $superclassTable) {
$found = true;
// Quiero la clase que genera la tabla anterior.
} else {
$prevClassToIterate = $classToIterate;
$classToIterate = get_parent_class($classToIterate);
}
}
return $prevClassToIterate;
}
public function test1()
{
PersistentManager::getInstance()->generateAll();
echo YuppConventions::tableName('Pagina') . "<br/>";
/**
* Resultado>
*
* CREATE TABLE test_a004_pagina (id INT(11) DEFAULT 1 PRIMARY KEY, titulo VARCHAR(255) NULL, contenido MEDIUMTEXT NULL, class TEXT NOT NULL, deleted BOOL NOT NULL, owner_id INT(11) NULL);
*
* CREATE TABLE test_a004_pagina_subpages_test_a004_pagina (id INT(11) DEFAULT 1 PRIMARY KEY, owner_id INT(11) NOT NULL, ref_id INT(11) NOT NULL, type INT(11) NOT NULL, deleted BOOL NOT NULL, class TEXT NOT NULL, ord INT(11) NULL);
*
* ALTER TABLE test_a004_pagina_subpages_test_a004_pagina ADD FOREIGN KEY (owner_id) REFERENCES test_a004_pagina(id);
*
* ALTER TABLE test_a004_pagina_subpages_test_a004_pagina ADD FOREIGN KEY (ref_id) REFERENCES test_a004_pagina(id);
*
* ALTER TABLE test_a004_pagina ADD FOREIGN KEY (owner_id) REFERENCES test_a004_pagina(id);
*
*/
// TODO: verificar si la tabla para Nariz y Cara fue creada.
//$dal = DAL::getInstance();
$dal = new DAL('tests');
$this->assert($dal->tableExists(YuppConventions::tableName('Pagina')), 'TestCaseA004: Test generar tabla');
}
/**
* Se recibe un objecto a la que ya se ha verificado que debe insertarse en la base de datos.
* @param $object POs a salvar.
*/
private function insert_query($object, $tableName = NULL)
{
Logger::getInstance()->dal_log("DAL:insert_query " . __FILE__ . " " . __LINE__);
// INSERT INTO hello_world_persona ( nombre ,edad ,class ,id ,deleted ) VALUES ('pepe' ,'12' ,'Persona' ,'6' ,'' );
if (!$tableName) {
$tableName = YuppConventions::tableName($object);
}
$q = "INSERT INTO " . $tableName . " ( ";
// DBSTD
$attrs = $object->getAttributeTypes();
// Recorro todos los atributos simples...
$tableAttrs = "";
foreach ($attrs as $attr => $type) {
$tableAttrs .= DatabaseNormalization::col($attr) . " ,";
// DBSTD
}
$tableAttrs = substr($tableAttrs, 0, sizeof($tableAttrs) - 2);
$q .= $tableAttrs;
$q .= ") VALUES (";
// El codigo es distinto al de update porque la forma de la consulta es distinta.
// TODO: Si el valor es null tengo que poner null en la tabla, no el string vacio.
// TODO: Verificar atributos no nullables en null en la instancia de la clase, esto falta agregar cosas a la clase persistente, "las restricciones"
$tableVals = "";
foreach ($attrs as $attr => $type) {
$value = $object->aGet($attr);
// Valor del atributo simple.
if ($value === NULL) {
$tableVals .= "NULL ,";
} else {
if (is_string($value)) {
$tableVals .= "'" . addslashes($value) . "' ,";
} else {
if (is_bool($value)) {
$tableVals .= "'" . ($value === true ? "1" : "0") . "' ,";
} else {
$tableVals .= "'" . $value . "' ,";
}
}
}
// FIXME: OJO, si no es literal no deberia poner comillas !!!! y si es null deberia guardar null
//echo $attr . " tiene tipo: " . gettype($value) . " y valor '" . $value . "'<br/>";
}
$tableVals = substr($tableVals, 0, sizeof($tableVals) - 2);
$q .= $tableVals;
$q .= ");";
// Si hay una excepcion, llega hasta la capa superior.
$this->db->execute($q);
}
private function test1()
{
PersistentManager::getInstance()->generateAll();
echo YuppConventions::tableName('M010_Persona') . "<br/>";
/**
* Resultado>
*
* CREATE TABLE test_m010_persona (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* nombre TEXT NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL
* );
*
* CREATE TABLE test_m010_persona_hijos_test_m010_persona (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* owner_id INT(11) NOT NULL,
* ref_id INT(11) NOT NULL,
* type INT(11) NOT NULL,
* deleted BOOL NOT NULL,
* class TEXT NOT NULL,
* ord INT(11) NULL
* );
*
*/
// TODO: verificar si la tabla para Nariz y Cara fue creada.
//$dal = DAL::getInstance();
$dal = new DAL('tests');
if ($dal->tableExists(YuppConventions::tableName('M010_Persona'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
}
private function test1()
{
PersistentManager::getInstance()->generateAll();
echo YuppConventions::tableName('Contenido1') . "<br/>";
echo YuppConventions::tableName('Recipiente1') . "<br/>";
echo YuppConventions::tableName('Vaso1') . "<br/>";
/**
* Resultado>
*
* CREATE TABLE test_i006_contenido1 (id INT(11) DEFAULT 1 PRIMARY KEY, elemento VARCHAR(30) NULL, volumen FLOAT NULL, class TEXT NOT NULL, deleted BOOL NOT NULL);
*
* CREATE TABLE test_i005_contenido (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* elemento VARCHAR(30) NULL,
* volumen FLOAT NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL
* );
*
* CREATE TABLE test_i006_vaso1 (id INT(11) DEFAULT 1 PRIMARY KEY, marca TEXT NULL, class TEXT NOT NULL, deleted BOOL NOT NULL, contenido_id INT(11) NULL, super_id_recipiente1 INT(11) NOT NULL);
*
* CREATE TABLE test_i005_vaso (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* marca TEXT NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL,
* contenido_id INT(11) NULL,
* super_id_recipiente INT(11) NOT NULL
* );
*
* CREATE TABLE test_i006_recipiente1 (id INT(11) DEFAULT 1 PRIMARY KEY, material VARCHAR(30) NULL, capacidad FLOAT NULL, tieneTapa BOOL NULL, class TEXT NOT NULL, deleted BOOL NOT NULL);
*
* CREATE TABLE test_i005_recipiente (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* material VARCHAR(30) NULL,
* capacidad FLOAT NULL,
* tieneTapa BOOL NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL
* );
*
* ALTER TABLE test_i006_vaso1 ADD FOREIGN KEY (super_id_recipiente1) REFERENCES test_i006_recipiente1(id);
*
* ALTER TABLE test_i005_vaso
* ADD FOREIGN KEY (super_id_recipiente)
* REFERENCES test_i005_recipiente(id);
*
* ALTER TABLE test_i006_vaso1 ADD FOREIGN KEY (contenido_id) REFERENCES test_i005_contenido(id);
*
* ALTER TABLE test_i005_vaso
* ADD FOREIGN KEY (contenido_id)
* REFERENCES test_i005_contenido(id);
*/
// TODO: verificar si la tabla para Nariz y Cara fue creada.
//$dal = DAL::getInstance();
$dal = new DAL('tests');
if ($dal->tableExists(YuppConventions::tableName('Contenido1'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
if ($dal->tableExists(YuppConventions::tableName('Recipiente1'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
if ($dal->tableExists(YuppConventions::tableName('Vaso1'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
}
public function dbStatusAction()
{
$yupp = new Yupp();
$appNames = $yupp->getAppNames();
$appModelClasses = array();
// [appName][class][tablename,creada o no]
// Incluye todas las clases del modelo de todas las apps
YuppLoader::loadModel();
// Para saber si se crearon las tablas para todas las
// clases del modelo de todas las aplicaciones.
$allTablesCreated = true;
$fn = new FileNames();
// http://code.google.com/p/yupp/issues/detail?id=123
$createDatabaseForApps = array();
// Aplicaciones a las que se sugiere que se cree su base de datos
foreach ($appNames as $appName) {
$app = new App($appName);
$modelClassFileNames = $app->getModel();
// no incluye las clases, solo obtiene los nombres
//print_r($modelClassFileNames);
// Necesito que sea plano el array, si no, tengo que hacer recorrida recursiva.
// Esto no seria necesario si modifico la recorrida en la vista, para mostrar
// la estructura interna de paquetes del modelo de la aplicacion.
$modelClassFileNames = $this->array_flatten($modelClassFileNames);
//print_r($modelClassFileNames);
// Toda la informacion de las clases y tablas creadas para esta app
$appModelClasses[$appName] = array();
// http://code.google.com/p/yupp/issues/detail?id=123
try {
$dal = new DAL($appName);
// Falla sino existe la base para la app $appName
} catch (Exception $e) {
if ($e->getCode() == 666) {
$createDatabaseForApps[] = $appName;
}
continue;
// Para el for appNames
}
foreach ($modelClassFileNames as $classFileName) {
$fileInfo = $fn->getFileNameInfo($classFileName);
$className = $fileInfo['name'];
// Para incluir las clases (por si no estan incluidas)
// Ticket: http://code.google.com/p/yupp/issues/detail?id=71
YuppLoader::load($fileInfo['package'], $className);
$tableName = YuppConventions::tableName($className);
if ($dal->tableExists($tableName)) {
$appModelClasses[$appName][$className] = array('tableName' => $tableName, 'created' => "CREADA");
} else {
$appModelClasses[$appName][$className] = array('tableName' => $tableName, 'created' => "NO CREADA");
$allTablesCreated = false;
}
}
}
$this->params['allTablesCreated'] = $allTablesCreated;
$this->params['appModelClasses'] = $appModelClasses;
$this->params['createDatabaseForApps'] = $createDatabaseForApps;
return $this->render("dbStatus");
}
public function test1()
{
$dal = new DAL('tests');
$this->assert($dal->tableExists(YuppConventions::tableName('Entidad')), 'Test 003.1.1 existe tabla');
$this->assert($dal->tableExists(YuppConventions::tableName('TestPersona')), 'Test 003.1.2 existe tabla');
}
/**
* Hace el include en las clases ya cargadas.
* En ludar de tener que ir al filesystem para cargar las clases del modelo,
* las carga de la memoria.
*/
public static function refresh()
{
$cl = YuppLoader::getInstance();
// FIXME: no recarga las clases del modelo que estan en subdirectorios!
foreach ($cl->loadedClasses as $classInfo) {
$package = $classInfo['package'];
$path = ".";
if (PackageNames::isModelPackage($package)) {
$path = YuppConventions::getModelPath($package);
} else {
$path = strtr($package, ".", "/");
}
$incPath = $path . "/" . $classInfo['filename'];
if (!is_file($incPath)) {
// FIXME: si se tira excepcion, me pasa que al mover archivos me da errores y tengo que borrar la sesion.
// igualmente en este caso deberia avisar de alguna forma de que no se encuentra una ruta de inclusion,
// por ejemplo haciendo log a disco. Tambien se podria sacar la entrada incorrecta.
//throw new Exception("YuppLoader::refresh() - ruta de inclusion errada ($incPath)");
} else {
include_once $incPath;
}
}
}
private function test1()
{
PersistentManager::getInstance()->generateAll();
echo YuppConventions::tableName('Dedo') . "<br/>";
echo YuppConventions::tableName('Mano') . "<br/>";
/**
* Resultado>
*
* CREATE TABLE test_m003_dedo (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* uniaLarga BOOL NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL
* );
*
* CREATE TABLE test_m003_mano (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* tamanio TEXT NULL,
* class TEXT NOT NULL,
* deleted BOOL NOT NULL
* );
*
* CREATE TABLE test_m003_mano_dedos_test_m003_dedo (
* id INT(11) DEFAULT 1 PRIMARY KEY,
* owner_id INT(11) NOT NULL,
* ref_id INT(11) NOT NULL,
* type INT(11) NOT NULL,
* deleted BOOL NOT NULL,
* class TEXT NOT NULL,
* ord INT(11) NULL
* );
*
* ALTER TABLE test_m003_mano_dedos_test_m003_dedo
* ADD FOREIGN KEY (owner_id)
* REFERENCES test_m003_mano(id);
*
* ALTER TABLE test_m003_mano_dedos_test_m003_dedo
* ADD FOREIGN KEY (ref_id)
* REFERENCES test_m003_dedo(id);
*
*/
// TODO: verificar si la tabla para Nariz y Cara fue creada.
//$dal = DAL::getInstance();
$dal = new DAL('tests');
if ($dal->tableExists(YuppConventions::tableName('Dedo'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
if ($dal->tableExists(YuppConventions::tableName('Mano'))) {
echo "Test 1 correcto";
} else {
echo "Test 1 Incorrecto";
}
}
private static function generateHasManyJoinTable($ins, $attr, $assocClassName, $dal)
{
Logger::getInstance()->pm_log("TableGen::generateHasManyJoinTable");
$tableName = YuppConventions::relTableName($ins, $attr, new $assocClassName());
//Logger::struct($this->getDataFromObject( new ObjectReference() ), "ObjRef ===");
// "owner_id", "ref_id" son FKs.
// Aqui se generan las columnas, luego se insertan las FKs
// =========================================================
$pks = array(array('name' => 'id', 'type' => Datatypes::INT_NUMBER, 'default' => 1));
$cols = array();
// FIXME: todo lo declarado aqui esta declarado en la clase ObjectReference,
// deberia hacerse referencia a eso en lugar de redeclarar todo
// (como los atributos y restricciones).
$cols[] = array('name' => "owner_id", 'type' => Datatypes::INT_NUMBER, 'nullable' => false);
$cols[] = array('name' => "ref_id", 'type' => Datatypes::INT_NUMBER, 'nullable' => false);
$cols[] = array('name' => "type", 'type' => Datatypes::INT_NUMBER, 'nullable' => false);
$cols[] = array('name' => "deleted", 'type' => Datatypes::BOOLEAN, 'nullable' => false);
$cols[] = array('name' => "class", 'type' => Datatypes::TEXT, 'nullable' => false);
// El tema con la columna ord es que igual esta declarada en la clase ObjectReference,
// entonces las consultas que se basen en los atributos que tenga la clase van a hacer
// referencia a "ord" aunque la coleccion hasMany no sea una lista.
// Entonces lo que hago es generar igual la columna ord aunque la coleccion no sea lista,
// y queda nullable, asi si es SET o COLLECTION no se da bola a ord.
$cols[] = array('name' => "ord", 'type' => Datatypes::INT_NUMBER, 'nullable' => true);
// Si es una lista se genera la columna "ord".
/*
$hmattrType = $ins->getHasManyType( $attr );
if ( $hmattrType === PersistentObject::HASMANY_LIST )
{
$cols[] = array(
'name' => "ord",
'type' => Datatypes :: INT_NUMBER, // Se de que tipo, esta definido asien PO.
'nullable' => true
);
}
*/
$dal->createTable2($tableName, $pks, $cols, array());
}
/** FIXME: no deberia ser de PO? o de MTISup? no deberia estar en PM deberia ser algo del model utils o mti support.
* Devuelve true si ambas clases se mapean en la misma tabla, las clases podrian ser
* superclase y subclase, ser clases primas, hermanas o no tener relacion alguna.
* Este metodo es mas general que isMappedOnSameTableSubclass.
*/
public static function isMappedOnSameTable($class1, $class2)
{
Logger::getInstance()->pm_log("PM::isMappedOnSameTable {$class1}, {$class2}");
// TODO
// el caso superclase subclase lo handlea isMappedOnSameTableSubclass.
$table1 = YuppConventions::tableName($class1);
$table2 = YuppConventions::tableName($class2);
//Logger::getInstance()->log( "isMappedOnSameTable: table1 $table1" );
//Logger::getInstance()->log( "isMappedOnSameTable: table2 $table2" );
return $table1 === $table2;
}
