public static void GuardarObjeto(ObjetoBase objetoGuardar)
{
Type tipo = objetoGuardar.GetType();
if (!almacen.ContainsKey(tipo))
{
almacen.Add(tipo, new Dictionary <long, ObjetoBase>());
}
if (almacen[tipo].ContainsKey(objetoGuardar.Id))
{
if (ActivarLog)
{
Log.EscribirLog("ALAMCEN <- : ACTUALIZADO. [OBJETO: " + tipo.Name + " ID: " + objetoGuardar.Id + "]");
}
almacen[tipo][objetoGuardar.Id] = objetoGuardar;
}
else
{
if (ActivarLog)
{
Log.EscribirLog("ALAMCEN <- : AGREGADO [OBJETO: " + tipo.Name + " ID: " + objetoGuardar.Id + "]");
}
almacen[tipo].Add(objetoGuardar.Id, objetoGuardar);
}
}
public void GuardarAsincrono(String identificador, ObjetoBase objBase)
{
PaqueteGuardado p = new PaqueteGuardado();
p.ObjetoBaseGuardar = objBase;
p.Identificador = identificador;
asincrono = new Thread(guardarAsincrono);
asincrono.Start((Object)p);
}
private Boolean existeObjetoModificado(ObjetoBase objAgregado)
{
foreach (ObjetoBase obj in objetosModificados)
{
Type t = obj.GetType();
Type t2 = objAgregado.GetType();
if (t == t2 && objAgregado.Id == obj.Id)
{
return(true);
}
}
return(false);
}
public T CrearObjeto <T>()
{
var obj = typeof(T)
.GetConstructor(Type.EmptyTypes)
.Invoke(null);
ObjetoBase objBase = (ObjetoBase)obj;
objBase.DBAccesoOBJ = this.dbAcceso;
objBase.Manejador = this;
return((T)obj);
}
public long Guardar(ObjetoBase objBase)
{
try
{
objBase.Manejador = this;
AlmacenObjetos.GuardarObjeto(objBase);
objBase.DBAccesoOBJ = this.dbAcceso;
objBase.SUsuarioResponsable = ObjetoBase.UsuarioLogueado;
return(objBase.Guardar());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public static ObjetoBase ObtenerObjeto(Type tipo, long id)
{
if (almacen.ContainsKey(tipo))
{
if (almacen[tipo].ContainsKey(id))
{
if (ActivarLog)
{
Log.EscribirLog("ALAMCEN ->: OBTENIDO [OBJETO: " + tipo.Name + " ID: " + id + "]");
}
ObjetoBase objeto = almacen[tipo][id];
//objeto.EliminarCache();
return(objeto);
}
}
return(null);
}
public void AgregarObjetoModificado(ObjetoBase objetoBase)
{
if (objetoBase.Id < 0)
{
return;
}
else if (objetoBase.Id == 0)
{
if (!objetosNuevos.Contains(objetoBase))
{
objetosNuevos.Add(objetoBase);
}
}
else if (!existeObjetoModificado(objetoBase))
{
objetosModificados.Add(objetoBase);
}
}
//agregar un elemento a lista
public void AgregadoRapidoAListaRelacionada(ObjetoBase objeto, String nombreLista)
{
try
{
Type tipo = this.GetType();
String nombreTablaRelacion = tipo.Name + "_X_" + objeto.GetType().Name + "_" + nombreLista;
objeto.dbAcceso = this.dbAcceso;
long idObjetoLista = objeto.Guardar();
String query = "insert into " + nombreTablaRelacion + "(_Contenedor, _Contenido) values (@_Contenedor, @_Contenido)";
dbAcceso.EjecutarConsulta(query, new List <object>()
{
id, idObjetoLista
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// Liberar recursos manejados
Type tipo = this.GetType();
FieldInfo[] atributos = tipo.GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
foreach (FieldInfo atributo in atributos)
{
if (atributo.FieldType.Name.Contains("List"))
{
IList lista = (IList)atributo.GetValue(this);
if (lista != null)
{
lista.Clear();
}
atributo.SetValue(this, null);
}
else if (atributo.FieldType.Name.StartsWith("_"))
{
ObjetoBase objB = (ObjetoBase)atributo.GetValue(this);
if (objB != null)
{
atributo.SetValue(this, null);
}
}
else
{
atributo.SetValue(this, null);
}
}
}
dbAcceso = null;
manejador = null;
AtributosCargadosPorPropiedad.Clear();
AtributosCargadosPorPropiedad = null;
AtributosCargadosPorPropiedadCopia.Clear();
AtributosCargadosPorPropiedadCopia = null;
this.id = -1;
}
public long Guardar()
{
try
{
Type tipo = this.GetType();
if (id < 0)
{
return(-1);
}
if (this.esModificado)
{
FieldInfo[] atributos = tipo.GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
String consulta = "";
List <Object> valores = new List <object>();
//actualizando datos de auditoria
if (id == 0)
{
dtFechaCreacion = manejador.ObtenerFechaHoraServidor();
sUsuarioCreacion = ObjetoBase.UsuarioLogueado;
}
dtFechaModificacion = manejador.ObtenerFechaHoraServidor();
sUsuarioModificacion = ObjetoBase.UsuarioLogueado;
//-----------------------------
if (id != 0)
{
consulta = "update " + tipo.Name + " set ";
foreach (FieldInfo atributo in atributos)
{
if (atributo.Name.Equals("dtFechaCreacion") || atributo.Name.Equals("dtFechaModificacion") || atributo.Name.Equals("sUsuarioCreacion") || atributo.Name.Equals("sUsuarioModificacion") || atributo.Name.Equals("estaDeshabilitado"))
{
}
else if (!atributo.Name.StartsWith("_") || atributo.FieldType.Name.Contains("List") || atributo.FieldType.Name.StartsWith("_"))
{
//|| atributo.Name.Equals("dtFechaCreacion") || atributo.Name.Equals("dtFechaModificacion") || atributo.Name.Equals("sUsuarioCreacion") || atributo.Name.Equals("sUsuarioModificacion"))
continue; // se ignoran las listas de objetos relacionados y los objetos relacionados
}
Object valorAtributo = atributo.GetValue(this);
if (valorAtributo != null)
{
consulta += atributo.Name + " = @" + atributo.Name + ", ";
valores.Add(valorAtributo);
}
else
{
consulta += atributo.Name + " = NULL, ";
}
}
consulta = consulta.Substring(0, consulta.Length - 2);
consulta += " where id = @id; select @id;";
valores.Add(id);
}
else
{
consulta = "insert " + tipo.Name + "(";
foreach (FieldInfo atributo in atributos)
{
if (atributo.Name.Equals("dtFechaCreacion") || atributo.Name.Equals("dtFechaModificacion") || atributo.Name.Equals("sUsuarioCreacion") || atributo.Name.Equals("sUsuarioModificacion") || atributo.Name.Equals("estaDeshabilitado"))
{
}
else if (!atributo.Name.StartsWith("_") || atributo.FieldType.Name.Contains("List") || atributo.FieldType.Name.StartsWith("_"))
{
//|| atributo.Name.Equals("dtFechaCreacion") || atributo.Name.Equals("dtFechaModificacion") || atributo.Name.Equals("sUsuarioCreacion") || atributo.Name.Equals("sUsuarioModificacion"))
continue; // se ignoran las listas de objetos relacionados y los objetos relacionados
}
consulta += atributo.Name + ", ";
}
consulta = consulta.Substring(0, consulta.Length - 2);
consulta += ") values(";
foreach (FieldInfo atributo in atributos)
{
if (atributo.Name.Equals("dtFechaCreacion") || atributo.Name.Equals("dtFechaModificacion") || atributo.Name.Equals("sUsuarioCreacion") || atributo.Name.Equals("sUsuarioModificacion") || atributo.Name.Equals("estaDeshabilitado"))
{
}
else if (!atributo.Name.StartsWith("_") || atributo.FieldType.Name.Contains("List") || atributo.FieldType.Name.StartsWith("_"))
{
continue; // se ignoran las listas de objetos relacionados y los objetos relacionados
}
Object valorAtributo = atributo.GetValue(this);
if (valorAtributo != null)
{
consulta += "@" + atributo.Name + ", ";
valores.Add(valorAtributo);
}
else
{
consulta += "NULL, ";
}
}
consulta = consulta.Substring(0, consulta.Length - 2);
consulta += "); select IDENT_CURRENT ('" + tipo.Name + "');";
}
DataTable dt = DBAccesoOBJ.EjecutarConsulta(consulta, valores);
id = Convert.ToInt64(dt.Rows[0][0]);
//Log.EscribirLog(consulta);
}
if (AtributosCargadosPorPropiedad.Count > 0)
{
String consulta2 = "update " + tipo.Name + " set ";
List <Object> valores2 = new List <object>();
List <String> temp = new List <string>();
temp.AddRange(AtributosCargadosPorPropiedad);
Boolean guardoRElaciondo = false;
foreach (String atributo in temp)
{
FieldInfo atrib = tipo.GetField(atributo, BindingFlags.Instance | BindingFlags.NonPublic);
if (atrib.FieldType.Name.StartsWith("_"))//si entra entonces es un objeto relacionado y se tiene q considerar
{
FieldInfo campo = this.GetType().GetField(atributo, BindingFlags.NonPublic | BindingFlags.Instance);
ObjetoBase objRel = (ObjetoBase)campo.GetValue(this);
if (esModificado)
{
if (objRel != null)
{
AtributosCargadosPorPropiedad.Remove(atributo);
long idRel = objRel.id;
if (objRel.esModificado)
{
objRel.DBAccesoOBJ = DBAccesoOBJ;
objRel.manejador = manejador;
idRel = objRel.Guardar();
}
if (idRel != 0)
{
guardoRElaciondo = true;
consulta2 += atributo + " = @" + atributo + ", ";
valores2.Add(idRel);
}
}
else
{
guardoRElaciondo = true;
AtributosCargadosPorPropiedad.Remove(atributo);
consulta2 += atributo + " = NULL, ";
}
}
else
{
AtributosCargadosPorPropiedad.Remove(atributo);
}
}
}
if (guardoRElaciondo)
{
consulta2 = consulta2.Substring(0, consulta2.Length - 2);
consulta2 += " where id = @id";
valores2.Add(id);
DBAccesoOBJ.EjecutarConsulta(consulta2, valores2);
//Log.EscribirLog(consulta2);
}
}
this.esModificado = false;
if (AtributosCargadosPorPropiedad.Count > 0)
{
List <Object> valores2 = new List <object>();
List <String> temp = new List <string>();
temp.AddRange(AtributosCargadosPorPropiedad);
foreach (String atributo in temp)
{
FieldInfo atrib = tipo.GetField(atributo, BindingFlags.Instance | BindingFlags.NonPublic);
if (atrib.FieldType.Name.Contains("List"))//si entra entonces es una lista relacionada y se tiene q considerar
{
AtributosCargadosPorPropiedad.Remove(atributo);
String nombreTabla = tipo.Name + "_X_" + atrib.FieldType.GetGenericArguments()[0].Name + "_" + atrib.Name;
String eliminacionConsulta = "delete " + nombreTabla + " where _contenedor = @id";
dbAcceso.EjecutarConsulta(eliminacionConsulta, new List <object>()
{
id
});
//Log.EscribirLog(eliminacionConsulta);
IList listaObjetos = (IList)atrib.GetValue(this);
if (listaObjetos != null)
{
foreach (ObjetoBase objBaseLista in listaObjetos)
{
long idTempLista = objBaseLista.id;
if (objBaseLista.esModificado)
{
objBaseLista.DBAccesoOBJ = this.DBAccesoOBJ;
objBaseLista.Manejador = manejador;
idTempLista = objBaseLista.Guardar();
}
String consultaAgregadoRelacionado = "insert " + nombreTabla + " (_contenedor,_contenido,_fecha) values(@_contenedor, @_contenido, @_fecha);";
dbAcceso.EjecutarConsulta(consultaAgregadoRelacionado, new List <object>()
{
id, idTempLista, DateTime.Now
});
//Log.EscribirLog(consultaAgregadoRelacionado);
}
}
}
}
}
return(id);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public List <ObjetoBase> Cargar(Type tipo, String consulta, List <Object> valores)
{
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
//AQUI SE TIENE Q BUSCAR LA SEPARACION DE BUSQUEDAS ENTRE ALMACEN DE OBJETOS Y BASE DE DATOS
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
try
{
DataTable resultado = null;
List <ObjetoBase> retorno = null;
//la consulta se cambia, para q solamente traiga IDS de la base de datos.
String consultaIDS = ModificarConsultaParaAlmacen(consulta);
Boolean TrajoIDS = false;
//UsarAlmacenObjetos = false; //deshabilitamos el almacen de objetos
// se intenta usar la consulta modificada
if (UsarAlmacenObjetos)
{
try
{
//se traen los ids de los objetos y se marca la variable de control
resultado = this.dbAcceso.EjecutarConsulta(consultaIDS, valores);
TrajoIDS = true;
}
catch
{
//si ocurrio un error, y se debio a que la consulta estaba mal modificada, entonces
//se usa la consulta original.
resultado = this.dbAcceso.EjecutarConsulta(consulta, valores);
}
}
if (TrajoIDS)
{
retorno = new List <ObjetoBase>();
List <long> idsRestantes = new List <long>();
ObjetoBase objetoTemp = null;
foreach (DataRow dr in resultado.Rows)
{
long idT = Convert.ToInt64(dr["id"]);
objetoTemp = AlmacenObjetos.ObtenerObjeto(tipo, idT);
if (objetoTemp != null)
{
retorno.Add(objetoTemp);
//Log.EscribirLog("ALMACEN: RETORNADO [tipo: "+tipo.Name+", id: "+idT+"].");
}
else
{
idsRestantes.Add(idT);
retorno.Add(null);
}
}
if (idsRestantes.Count > 0)
{
String stridsRestantes = "";
foreach (long idR in idsRestantes)
{
stridsRestantes += "(" + idR + "), ";
}
stridsRestantes = stridsRestantes.Substring(0, stridsRestantes.Length - 2);
//String consultaIdStr = "select * from " + tipo.Name + " where id in " + stridsRestantes;
String consultaIdStr = @"select tabla.* from " + tipo.Name + @" as tabla
inner join (values " + stridsRestantes + @") as Valores(id)
on tabla.id = Valores.id;";
DataTable resultado2 = dbAcceso.EjecutarConsulta(consultaIdStr); // id = @id", new List<object>() { idT });
if (resultado2.Rows.Count > 0)
{
IList retorTemp = dbAcceso.MapearDataTableAObjecto(tipo, resultado2);
int i = 0;
foreach (ObjetoBase o in retorTemp)
{
AlmacenObjetos.GuardarObjeto(o);
for (; i < retorno.Count; i++)
{
if (retorno[i] == null)
{
retorno[i] = o;
break;
}
}
//retorno.Add(o);
//Log.EscribirLog("ALMACEN: AGREGADO [tipo: " + tipo.Name + ", id: " + idT + "].");
}
}
}
}
else
{
resultado = this.dbAcceso.EjecutarConsulta(consulta, valores);
//Log.EscribirLog("ALMACEN: ERROR Fallo al convertir la consulta.");
if (resultado.Rows.Count > 0)
{
retorno = dbAcceso.MapearDataTableAObjecto(tipo, resultado).Cast <ObjetoBase>().ToList();
foreach (ObjetoBase o in retorno)
{
o.Manejador = this;
AlmacenObjetos.GuardarObjeto(o);
}
}
}
if (retorno != null)
{
foreach (ObjetoBase objBase in retorno)
{
objBase.Manejador = this;
objBase.DBAccesoOBJ = dbAcceso;
}
}
//resultado = this.dbAcceso.EjecutarConsulta(consulta, valores);
//if (resultado.Rows.Count > 0)
//{
// retorno = dbAcceso.MapearDataTableAObjecto(tipo, resultado);
// foreach (ObjetoBase o in retorno)
// {
// AlmacenObjetos.GuardarObjeto(o);
// }
//}
if (retorno == null)
{
return(null);
}
return(retorno.Cast <ObjetoBase>().ToList());
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
