/// <summary>
/// Obtiene un elemento (1 fila) de la respuesta obtenida al ejecutar la instancia actual (Procedimiento Almacenado).
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <typeparam name="T">Tipo de la respuesta (fila).</typeparam>
/// <returns>Una instancia cargada del tipo especificado, y datos retornados por la ejecución.</returns>
/// <exception cref="System.ArgumentException">Excepción lanzada al no establecer el nombre del procedimiento almacenado.</exception>
/// <exception cref="Ada.Framework.Data.DBConnector.Exceptions.EjecutarException">Excepción lanzada al ocurrir un error al realizar la consulta.</exception>
/// <exception cref="Ada.Framework.Data.DBConnector.Exceptions.ConexionException">Excepción lanzada al existir un problema al abrir la conexión.</exception>
/// <exception cref="System.ArgumentException">Excepción lanzada al existir un problema con la cadena de conexión(ConnectionString).</exception>
/// <exception cref="Ada.Framework.Data.DBConnector.Exceptions.ConexionException">Excepción lanzada al existir un problema al cerrar la conexión.</exception>
public virtual new RespuestaEjecucion <T> Obtener <T>()
{
try
{
if (Conexion.AutoConectarse && Conexion.dbConnection.State != ConnectionState.Open)
{
Conexion.dbConnection.Open();
}
IDbCommand comando = CrearComando();
IDataReader reader = CargarParametros(ref comando).ExecuteReader();
RespuestaEjecucion <T> retorno = new RespuestaEjecucion <T>();
if (reader.Read())
{
retorno = Mapeador.Mapear <T>(reader, CampoPropiedad);
}
if (Conexion.AutoConectarse && Conexion.dbConnection.State != ConnectionState.Closed)
{
Conexion.dbConnection.Close();
}
return(retorno);
}
catch (Exception e)
{
throw new EjecutarException(e.Message, e);
}
}
/// <summary>
/// Mapea la respuesta de la ejecución de un comando a el tipo C# especificado.
/// Puede ser un objeto definido por el usuario, por ejemplo, un TO.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <typeparam name="T">Tipo de la respuesta (entidad).</typeparam>
/// <param name="record">Respuesta obtenida de la ejecución de un comando en una base de datos.</param>
/// <param name="campoPropiedad">Diccionario que asocia el campo de la respuesta con una propiedad de un objeto.</param>
/// <returns>Una instancia cargada del tipo especificado y datos obtenidos de IDataReader (parámetro).</returns>
/// <exception cref="System.InvalidOperationException">Excepción lanzada al ocurrir un erro al mapear la respuesta.</exception>
public virtual RespuestaEjecucion <T> Mapear <T>(IDataRecord record, IDictionary <string, string> campoPropiedad)
{
if (record == null)
{
throw new NullReferenceException("¡Record no puede ser nulo!");
}
if (campoPropiedad == null)
{
throw new NullReferenceException("¡CampoPropiedad no puede ser nulo!");
}
try
{
RespuestaEjecucion <T> retorno = new RespuestaEjecucion <T>();
//Si es un objeto definido por el usuario.
if (!ObjetoFactory.ObtenerObjeto().esPrimitivo(typeof(T)))
{
bool esInmutable = false;
//Obtener los atributos personalizados (Annotations) del tipo.
var attributos = typeof(T).GetCustomAttributes(false);
foreach (var atributo in attributos)
{
if (atributo is Inmutable)
{
esInmutable = (atributo as Inmutable).EsInmutable;
}
}
if (!esInmutable)
{
retorno.Respuesta = Activator.CreateInstance <T>();
IList <PropertyInfo> parametros = typeof(T).GetProperties();
for (int x = 0; x < record.FieldCount; x++)
{
string campo = record.GetName(x);
bool existeCampo = false;
PropertyInfo[] propiedades = retorno.Respuesta.GetType().GetProperties();
foreach (PropertyInfo propiedad in propiedades)
{
//Comprueba existencia de Property con mismo nombre que el campo y el mismo tipo.
if (propiedad.Name == campo)
{
if (record.GetValue(x).GetType() == propiedad.PropertyType)
{
object valor = record[x];
if (valor.GetType() == typeof(DBNull))
{
valor = null;
}
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
propiedad.SetValue(retorno.Respuesta, valor, null);
existeCampo = true;
break;
}
else if (ObjetoFactory.ObtenerObjeto().esEnumeracion(propiedad.PropertyType))
{
try
{
object valorEnum = Enum.Parse(propiedad.PropertyType, record.GetString(x));
propiedad.SetValue(retorno.Respuesta, valorEnum, null);
}
catch { }
}
}
}
//Si no existe una coincidencia directa (nombre) entre Campo y Propiedad.
if (!existeCampo)
{
//Obtiene desde el diccionario la propiedad correspondiente al campo y carga el valor.
object valor = record[x];
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
//Comprueba existencia de Mapeador entre Campo y Propiedad.
if (campoPropiedad != null)
{
bool existePropiedad = false;
foreach (string xpropCampoPropiedad in campoPropiedad.Keys)
{
if (valor.GetType() == typeof(DBNull))
{
valor = null;
}
if (xpropCampoPropiedad.Contains(campo))
{
existePropiedad = true;
ObjetoFactory.ObtenerObjeto().SetValorPropiedad(retorno.Respuesta, xpropCampoPropiedad, valor);
}
}
if (!existePropiedad)
{
//Agrega el campo a las propiedades omitidas.
retorno.PropiedadesOmitidas.Add(campo, valor);
}
}
else
{
//Agrega el campo a las propiedades omitidas.
retorno.PropiedadesOmitidas.Add(campo, valor);
}
}
}
return(retorno);
}
else
{
for (int x = 0; x < record.FieldCount; x++)
{
string campo = record.GetName(x);
object valor = record.GetValue(x);
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
retorno.PropiedadesOmitidas.Add(campo, valor);
}
return(retorno);
}
}
else
{
object valor = record.GetValue(0);
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
return(new RespuestaEjecucion <T>()
{
Respuesta = (T)Convert.ChangeType(valor, typeof(T), CultureInfo.InvariantCulture)
});
}
}
catch (Exception e)
{
throw new InvalidOperationException("¡No se ha podido convertir la respuesta al tipo especificado!", e);
}
}
