public T findByPrimaryKeyRecursive(String valor) {
T obj = getObjectBlank();
Columna columna = obj.getMapeo().getColumaPk();
String query =
"SELECT * FROM "
+ obj.getMapeo().getNombreTabla()
+ " WHERE "
+ columna.getName()
+ "='"
+ valor
+ "'";
System.out.println(query);
ResultSet rs = this.conexion.ejecutarConsulta(query);
if (sizeResulSet(rs) == 0) {
return null;
}
try {
rs.beforeFirst();
} catch (SQLException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
}
// System.out.println(query);
return convertAnObject(rs);
}
/**
* Obejto que permite comunicarme con la base de datos
*
* @param i objeto que implemente la interfaz Mapeo
*/
public void insert(T i) {
i.setMapeo();
Mapeo mapeo = i.getMapeo();
ArrayList<Columna> columnas = mapeo.getColumnas();
String consulta = "INSERT INTO " + mapeo.getNombreTabla() + "(";
for (int j = 0; j < columnas.size(); j++) {
Columna c = columnas.get(j);
if (j == (columnas.size() - 1)) {
consulta = consulta + c.getName();
} else {
consulta = consulta + c.getName() + ",";
}
}
consulta = consulta + ") VALUES (";
for (int j = 0; j < columnas.size(); j++) {
try {
Columna c = columnas.get(j);
// obtener el metodo get para acceder a los datos
String texto = c.getRefAtributo().getName();
String nombreMetodo =
"get" + Character.toUpperCase(texto.charAt(0)) + texto.substring(1, texto.length());
;
Method metodoGetValor = findMethod(i.getClass().getMethods(), nombreMetodo);
Object valor = metodoGetValor.invoke(i);
if (j == (columnas.size() - 1)) {
consulta = consulta + "'" + valor.toString() + "'";
} else {
consulta = consulta + "'" + valor.toString() + "',";
}
} catch (IllegalAccessException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalArgumentException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (InvocationTargetException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
}
}
consulta = consulta + ");";
System.out.println(consulta);
this.conexion.ejecutarQuery(consulta);
}
private List<T> arrayToObject(ResultSet r) {
List<T> lista = new LinkedList<>();
// Object []lista = new Object[sizeResulSet(r)];
AbstractMapeo obj = getObjectBlank();
Columna columna = obj.getMapeo().getColumaPk();
int i = 0;
try {
r.beforeFirst();
while (r.next()) {
// T o=convertAnObject(r);
T o = findByPrimaryKeyRecursive(r.getObject(columna.getName()).toString());
lista.add(o);
}
} catch (SQLException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
}
return lista;
}
/**
* Funcion que permite realizar la conversion entre tipo de datos de Resulset en Datos
*
* @param one variable para saber si
*/
private T convertAnObject(ResultSet r) {
// this.contListaObjRef++;
try {
if (r.isBeforeFirst()) r.next();
// while(r.next())
// {
T objBlanco = getObjectBlank();
ArrayList<Columna> columnas = objBlanco.getMapeo().getColumnas();
for (Columna columna : columnas) {
Field field = columna.getRefAtributo();
// System.out.println(columna.getName());
// field.set(objBlanco,valor);
String nameAtributo = field.getName();
char primero = nameAtributo.charAt(0);
String texto = nameAtributo;
texto = "set" + Character.toUpperCase(primero) + texto.substring(1, texto.length());
Method[] metodos = getClassEntity().getMethods();
// buscar el metodo que coincida con el nombre del atributo con el metodo set
Method metodoEncontrado = findMethod(getClassEntity().getMethods(), texto);
// verificar si el valor es directo o es una referencia fk
String tipoClave = columna.getTypekey();
if (tipoClave.equals("fk")) {
String tipo = field.getType().getName();
Object value = r.getString(columna.getName());
String nombreClaseReferencia = tipo;
Class claseReferencia = Class.forName(nombreClaseReferencia);
/// verificar que el objeto exista no exista en la lista
Object objReferencia;
Object tempReferencia = findLista(newObjectPrimaryKey(claseReferencia, value));
if (tempReferencia != null) {
objReferencia = tempReferencia;
} else {
// cuando no existe el objeto
Method metodoGetFacade = findMethod(claseReferencia.getMethods(), "getDao");
Class claseFacade = (Class) metodoGetFacade.invoke(claseReferencia.newInstance());
Method metodoFindPrimaryKey =
findMethod(claseFacade.getMethods(), "findByPrimaryKeyRecursive");
AbstractFacade facadeReferencia = (AbstractFacade) claseFacade.newInstance();
objReferencia = metodoFindPrimaryKey.invoke(facadeReferencia, value);
AbstractFacade.addLista((AbstractMapeo) objReferencia);
}
// agrega el objeto de referencia al objeto principal
metodoEncontrado.invoke(objBlanco, objReferencia);
} else {
// obtner el valor segun el tipo de dato del atributo
String tipo = field.getType().getSimpleName();
String nombreColumna = columna.getName();
Object value = r.getObject(nombreColumna);
// System.out.println(value.getClass().getTypeName());
metodoEncontrado.invoke(objBlanco, value);
}
}
// agregar el objeto a la lista si no se encuentra
if (!AbstractFacade.isFindLista(objBlanco)) {
AbstractFacade.addLista(objBlanco);
}
//// consultar los arrays enlazados dentro de cada objeto
List<Lista> areglos = objBlanco.getMapeo().getArrays();
for (Lista areglo : areglos) {
Class claseResultado = areglo.getClase();
String tabla = areglo.getTablaBusqueda();
String condicion = areglo.getKeyNameFilter();
// obtener el valor de la clave principal
Columna columaPk = objBlanco.getMapeo().getColumaPk();
String texto = columaPk.getName();
String nombreMetodo =
"get" + Character.toUpperCase(texto.charAt(0)) + texto.substring(1, texto.length());
;
Method metodoGetValor = findMethod(objBlanco.getClass().getMethods(), nombreMetodo);
Object valor = metodoGetValor.invoke(objBlanco);
String consulta =
"SELECT * FROM " + tabla + " WHERE " + condicion + "='" + valor.toString() + "'";
System.out.println(consulta);
ResultSet rs = this.conexion.ejecutarConsulta(consulta);
// recorrer uno por uno para obtner la variable de la columna que necesito
int tamnioArray = sizeResulSet(r);
Object arrayResultado = Array.newInstance(claseResultado, tamnioArray);
r.beforeFirst();
int indice = 0;
while (rs.next()) {
// obtengo el valor de la columna de que corresponde al objeto de la solucion
Object valorRespuesta = rs.getObject(areglo.getKeyNameResult());
Object objResultado;
Object tempReferencia = findLista(newObjectPrimaryKey(claseResultado, valorRespuesta));
if (tempReferencia != null) {
objResultado = tempReferencia;
} else {
Object objRes = claseResultado.newInstance();
Method metodoGetDao = findMethod(objRes.getClass().getMethods(), "getDao");
Class classDao = (Class) metodoGetDao.invoke(objRes);
Object objDao = classDao.newInstance();
Method metodoFindPrimaryKey =
findMethod(classDao.getMethods(), "findByPrimaryKeyRecursive");
// ObjectnewObjectPrimaryKey(classDao,valorRespuesta);
// encuentro un objeto del tipo respuesta para agregar a la lista de referencias
Method metodoGetObjectBlanck = findMethod(classDao.getMethods(), "getObjectBlank");
objResultado = metodoGetObjectBlanck.invoke(objDao);
objResultado = newObjectPrimaryKey(objResultado.getClass(), valorRespuesta);
AbstractFacade.addLista((AbstractMapeo) objResultado);
objResultado = metodoFindPrimaryKey.invoke(objDao, valorRespuesta);
}
// Array.set(arrayResultado,indice++,claseResultado.cast(objResultado));
areglo.copyObj(objResultado);
}
////////// convertir de array en una lista para asignar
// List listaResultado=Arrays.asList(arrayResultado);
// areglo.copyList((Object[]) arrayResultado);
// areglo.getKeyNameFilter();
}
return objBlanco;
// }
} catch (SQLException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalArgumentException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (SecurityException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (InvocationTargetException ex) {
System.out.println(ex.getCause());
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
Logger.getLogger(AbstractFacade.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}