/// <summary>
/// Método static y común a todas las 'Entidades' que devuelve en formato byte[] una imagen de la B.D.
/// </summary>
/// <param name="campo">Nombre del campo con la imagen.</param>
/// <param name="tabla">Nombre de la tabla en la B.D.</param>
/// <param name="condicion">Condición en formato SQL de la fila de la que se quiere obtener la imagen.</param>
/// <returns>La imagen en formato byte[]. / null.- Si la fila no tiene imagen.</returns>
protected static byte[] SelectImage(string campo, string tabla, string condicion)
{
byte[] foto;
using (AccesoSql asql = CrearAccesoSQL())
{
foto = asql.SelectFoto(campo, tabla, condicion);
}
return(foto);
}
/// <summary>
/// Este método devuelve el nº de filas en la B.D. de tabla que representa la clase 'Entidad'.
/// <param name="condicion">Condición para las filas que se deben contar. Si no hay condición,
/// se cuentan todas las filas de la Tabla/Entidad.</param>
/// </summary>
/// <returns>Nº de filas en la base de datos.</returns>
public static long TotalFilas <T>(string condicion = "") where T : EntidadSQL, new()
{
long nFilas = 0;
T entidad = new T();
using (AccesoSql asql = CrearAccesoSQL())
{
nFilas = asql.TotalFilas(entidad.GetTabla(), condicion);
}
return(nFilas);
}
/// <summary>
/// Este método inserta un registro/fila con los valores del objeto 'Entidad' actual en la B.D. y tabla
/// correspondientes.
/// </summary>
/// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro
/// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite
/// el uso de transacciones Sql entre distintos objetos 'EntidadSql'.</param>
/// <returns>True.- Si se pudo realizar la insercción. False.- Si no se pudo realizar la insercción.</returns>
protected virtual bool Insertar()
{
bool cerrarConexion = (transactionSql == null) ? true : false;
AccesoSql asql = (transactionSql == null) ? CrearAccesoSQL() : transactionSql.accesoSql;
CampoID = asql.Insert(GetTabla(), NombresCamposBD(false), ValoresCamposBD(false));
if (cerrarConexion)
{//Si existe un objeto 'TransactionSQL' para este objeto, esta instrucción sql forma parte de una transacción y
//comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario.
asql.Dispose();
}
return(CampoID != -1);
}
public static AccesoSql CrearAccesoSQL()
{//Crea y devuelve el objeto 'AccesoSQL' según si los datos para la conexión al servidor SQL están en
//un archivo de configuración de la aplicación o se recibieron en el constructor de la clase 'Entidad'.
AccesoSql asql;
if (tipoConex == TipoConexion.Manual)
{
asql = new AccesoSql(dataSource, initialCatalog, userID, password);
}
else
{
asql = (nombreConnectionStringWebConfig == "") ? new AccesoSql() : new AccesoSql(nombreConnectionStringWebConfig);
}
return(asql);
}
public static FilasDB EjecutaSQL(SqlCommand cmdSQL, AccesoSql _accesoSql = null)
{
FilasDB filas;
bool cerrarConexion = (_accesoSql == null) ? true : false;
AccesoSql asql = (_accesoSql == null) ? CrearAccesoSQL() : _accesoSql;
filas = asql.Ejecuta(cmdSQL);
if (cerrarConexion)
{//Si se recibió un objeto 'AccesoSql' como parámetro entonces esta instrucción sql forma parte de una transacción o
//comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario.
asql.Dispose();
}
return(filas);
}
/// <summary>
/// Método static y común a todas las clases 'Entidades' que actualiza un campo en la B.D. con una imagen
/// en formato byte[].
/// </summary>
/// <param name="campo">Nombre del campo para la imagen</param>
/// <param name="tabla">Nombre de la tabla en la B.D.</param>
/// <param name="condicion">Condición en formato SQL de la fila/filas donde se quiere modificar la imagen.</param>
/// <param name="image">La imagen en formato byte[].</param>
/// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro
/// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite
/// el uso de transacciones Sql entre distintos objetos 'EntidadSql'.
/// </param>
/// <returns>True.- Si se consiguió actualizar el campo de la imagen en la B.D.
/// False.- Si no se consiguió actualizar el campo de la imagen en la B.D.</returns>
protected static bool UpdateImage(string campo, string tabla, string condicion, byte[] image, AccesoSql _accesoSql = null)
{
bool todoOK;
bool cerrarConexion = (_accesoSql == null) ? true : false;
AccesoSql asql = (_accesoSql == null) ? CrearAccesoSQL() : _accesoSql;
todoOK = asql.UpdateFoto(campo, tabla, condicion, image);
if (cerrarConexion)
{//Si se recibió un objeto 'AccesoSql' como parámetro, esta instrucción sql forma parte de una transacción y
//comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario.
asql.Dispose();
}
return(todoOK);
}
/// <summary>
/// Este método borra el registro/fila de la B.D. correspondiente a esta clase 'Entidad' (mismo Id).
/// </summary>
/// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro
/// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite
/// el uso de transacciones Sql entre distintos objetos 'EntidadSql'.
/// </param>
/// <returns>True.- Se pudo borrar el registro de la B.D. False.- No se pudo borrar el registro en la B.D.</returns>
public virtual bool Borrar()
{
int nRegs;
CadenaParametro condicion = new CadenaParametro(NombreCampoID(), "=", CampoID);
bool cerrarConexion = (transactionSql == null) ? true : false;
AccesoSql asql = (transactionSql == null) ? CrearAccesoSQL() : transactionSql.accesoSql;
nRegs = asql.Delete(GetTabla(), condicion);
if (cerrarConexion)
{//Si existe un objeto 'TransactionSQL' para este objeto, esta instrucción sql forma parte de una transacción y
//comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario.
asql.Dispose();
}
return(nRegs > 0);
}
/// <summary>
/// Método static y genérico que realiza una consulta en la tabla de la B.D. correspondiente al tipo
/// de clase 'Entidad' recibida como parámetro genérico.
/// </summary>
/// <typeparam name="T">Clase derivada de 'EntidadSQL' y que defina un constructor por defecto.</typeparam>
/// <param name="condicion">string con la condicion en formato SQL para seleccionar la/s filas
/// de la tabla correspondiente en la B.D.</param>
/// <param name="orderByCampo">Nombre del campo por el que se deben de ordenar la filas devueltas
/// por la consulta.</param>
/// <returns>Objeto List del tipo genérico recibido como parámetro en el método."/></returns>
protected static List <T> Listar <T>(string orderByCampo = "", params CadenaParametro[] condicion) where T : EntidadSQL, new()
{
List <T> filasConsulta = new List <T>();
FilasDB filas;
T entidad = new T();
using (AccesoSql asql = CrearAccesoSQL())
{
filas = asql.Select(entidad.GetTabla(), entidad.NombresCamposBD(true), orderByCampo, condicion);
}
foreach (Object[] item in filas)
{
T newEntidad = new T();
newEntidad.AsignarValorCamposBD(item, true);
filasConsulta.Add(newEntidad);
}
return(filasConsulta);
}
/// <summary>
/// Método static y genérico que realiza una consulta en la tabla de la B.D. corespondiente al tipo
/// de la clase 'Entidad' recibida como parámetro genérico pero seleccionando solo aquellas filas cuya
/// posición esté dentro de los parámetros 'posIni' y 'posFin'.
/// </summary>
/// <typeparam name="T">Clase derivada de 'EntidadSQL' y que defina un constructor por defecto.</typeparam>
/// <param name="posIni">Indica la posición de la primera fila resultado de la consulta.</param>
/// <param name="posFin">Indica la posición de la última fila resultado de la consulta.</param>
/// <param name="condicion">Solo se enumerarán aquellas filas que cumplan la condición indicada. Si no hay
/// condición, se seleccionan todas las filas dentro del margen de posición indicado.</param>
/// <param name="orderCampo">Nombre del campo de la tabla por el que se ordenarán las filas. Si es igual a
/// "" no se ordenará por ningún campo y se respetará la posición de las filas en B.D.</param>
/// <param name="orderAsc">True: Se ordenan las filas de menor a mayor por el campo indicado.
/// False: Se ordenan las filas de mayor a menor por el campo indicado.</param>
/// <returns></returns>
protected static List <T> ListarPage <T>(int posIni, int posFin, string condicion = "", string orderCampo = "", bool orderAsc = true)
where T : EntidadSQL, new()
{
List <T> filasConsulta = new List <T>();
FilasDB filas;
T entidad = new T();
using (AccesoSql asql = CrearAccesoSQL())
{
filas = asql.SelectPage(entidad.GetTabla(), entidad.NombresCamposBD(true), posIni, posFin, condicion, orderCampo, orderAsc);
}
foreach (Object[] item in filas)
{
T newEntidad = new T();
newEntidad.AsignarValorCamposBD(item, true);
filasConsulta.Add(newEntidad);
}
return(filasConsulta);
}
/// <summary>
/// Este método crea el objeto 'AccesoSql' con una conexión abierta y una transacción. Se asigna dicho objeto al campo
/// 'accesoSql' de todos los objetos derivados de la clase 'EntidadSQL' en la lista 'EntidadesSql'.
/// </summary>
/// <returns></returns>
private void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
{
_accesoSql = EntidadSQL.CrearAccesoSQL();
_accesoSql.BeginTransaction(isolationLevel);
}
