public ResultadoBd ActualizarDvvDeTabla(string nombreTabla, List <string> lstDvh)
{
string dvvNuevo = null;
foreach (string dvh in lstDvh)
{
dvvNuevo += dvh;
}
dvvNuevo = DigitoVerificador.CrearHash(dvvNuevo);
BE.DVV dvvBase = ObtenerDvvPorNombreDeTabla(nombreTabla);
if (dvvBase != null)
{
dvvBase.Valor = dvvNuevo;
}
else
{
dvvBase = new BE.DVV {
NombreTabla = nombreTabla, Valor = dvvNuevo
};
return(Agregar(dvvBase));
}
return(Editar(dvvBase));
}
public void Insertar(BE.DVV dvv)
{
try
{
mp.Insertar(dvv);
}
catch (Exception) { }
}
public int Insertar(BE.DVV dvv)
{
int fa;
SqlParameter[] parametros =
{
new SqlParameter("@TABLA", dvv.Tabla),
new SqlParameter("@DVV", dvv.Digito)
};
fa = sh.Escribir("INSERTAR_DVV", parametros);
return(fa);
}
public void ActualizarDVV()
{
List <BE.DVV> lsDVV = this.Listar();
List <BE.Usuario> lsUsuarios = gestorUsuario.Listar();
List <BE.Capsula> lsCapsulas = gestorCapsula.Listar();
foreach (BE.DVV dvv in lsDVV)
{
if (dvv.Tabla == "USUARIO")
{
BE.DVV nuevoDVV = new BE.DVV();
nuevoDVV.Tabla = dvv.Tabla;
if (lsUsuarios.Count > 0)
{
foreach (BE.Usuario u in lsUsuarios)
{
nuevoDVV.Digito = nuevoDVV.Digito + u.DVH;
}
nuevoDVV.Digito = GestorHash.GenerarHash(nuevoDVV.Digito);
this.Insertar(nuevoDVV);
nuevoDVV = null;
}
}
if (dvv.Tabla == "CAPSULA")
{
BE.DVV nuevoDVV = new BE.DVV();
nuevoDVV.Tabla = dvv.Tabla;
if (lsCapsulas.Count > 0)
{
foreach (BE.Capsula c in lsCapsulas)
{
nuevoDVV.Digito = nuevoDVV.Digito + c.DVH;
}
nuevoDVV.Digito = GestorHash.GenerarHash(nuevoDVV.Digito);
this.Insertar(nuevoDVV);
nuevoDVV = null;
}
}
}
}
public List <BE.DVV> Listar()
{
DataTable tabla = sh.Leer("LISTAR_DVV", null);
List <BE.DVV> ls = new List <BE.DVV>();
foreach (DataRow r in tabla.Rows)
{
BE.DVV dvv = new BE.DVV();
dvv.Tabla = (string)r["TABLA"];
try
{
dvv.Digito = (string)r["DVV"];
}
catch (Exception)
{
dvv.Digito = null;
throw;
}
ls.Add(dvv);
}
return(ls);
}
public List <BE.DVV> Leer()
{
var ls = new List <BE.DVV>();
BE.DVV beDVV = new BE.DVV();
var dt = _accesoBaseDeDatos.Seleccionar(new BE.DVV(), false);
foreach (DataRow row in dt.Rows)
{
var aDVV = new BE.DVV
{
Id = Convert.ToInt32(row["Id"]),
NombreTabla = row["NombreTabla"].ToString().Trim(),
Valor = row["Valor"].ToString().Trim(),
};
ls.Add(aDVV);
}
return(ls);
}
/// <summary>
/// Obtiene un DVV por nombre de tabla.
/// </summary>
/// <param name="nombreTabla">Nombre del DVV.</param>
/// <returns></returns>
public BE.DVV ObtenerDVVPorNombreDeTabla(string nombreTabla)
{
var dtDVV = _accesoBaseDeDatos.Seleccionar(new BE.DVV()
{
NombreTabla = nombreTabla
}, true);
if (dtDVV.Rows.Count == 0)
{
return(null);
}
var row = dtDVV.Rows[0];
var aDVV = new BE.DVV
{
Id = Convert.ToInt32(row["Id"]),
NombreTabla = row["NombreTabla"].ToString().Trim(),
Valor = row["Valor"].ToString().Trim(),
};
return(aDVV);
}
/// <summary>
/// Quita un DVV.
/// </summary>
/// <param name="pDvv">DVV a quitar.</param>
/// <returns></returns>
public ResultadoBd Quitar(BE.DVV pDvv)
{
return(_dalManagerDvv.Borrar(pDvv));
}
/// <summary>
/// Edita un DVV.
/// </summary>
/// <param name="pDvv">DVV a editar.</param>
/// <returns></returns>
public ResultadoBd Editar(BE.DVV pDvv)
{
return(_dalManagerDvv.Actualizar(pDvv));
}
/// <summary>
/// Agrega un nuevo DVV al sistema.
/// </summary>
/// <param name="pDvv">DVV a agregar.</param>
/// <returns></returns>
public ResultadoBd Agregar(BE.DVV pDvv)
{
return(_dalManagerDvv.Insertar(pDvv));
}
public EstadoBaseDeDatos ValidarBasedeDatos()
{
BLL.Sistema bllSistema = new BLL.Sistema();
EstadoBaseDeDatos resultado = new EstadoBaseDeDatos();
try
{
string todosLosDvh = null;
resultado.EsValida = true;
//CALCULO DE TODOS LOS DVH
//Obtengo todos los nombres de las tablas de la base de datos
List <string> nombresDeTablas = ObtenerNombresDeTablas();
foreach (string nombreTabla in nombresDeTablas)
{
//Obtengo el contenido de la tabla actual
DataTable tabla = bllSistema.LeerTablaPorNombre(nombreTabla);
string dvvCalculado = "";
bool tablaValida = true;
for (int row = 0; row <= tabla.Rows.Count - 1; row++)
{
//Calculo el DVH
string dvhCalculado = DigitoVerificador.CalcularDvhDeFila(tabla, row);
todosLosDvh = todosLosDvh + dvhCalculado;
if (!tabla.Rows[row]["DVH"].ToString().Equals(dvhCalculado))
{
//Si el DVH guardado en la base es distinto al DVH recien calculado
//indica que hubo una modificacion del registro, sin actualizar el DVH
resultado.RegistrosCorruptos.Add("Error de integridad en la tabla -" + nombreTabla +
"- en el registro " + tabla.Rows[row][0].ToString());
resultado.EsValida = false;
tablaValida = false;
}
dvvCalculado += tabla.Rows[row]["DVH"].ToString();
}
if (tablaValida)
{
BE.DVV aDvv = _dalManagerDvv.ObtenerDVVPorNombreDeTabla(nombreTabla);
dvvCalculado = DigitoVerificador.CrearHash(dvvCalculado);
resultado.EsValida = dvvCalculado.Equals(aDvv.Valor);
if (!resultado.EsValida)
{
resultado.RegistrosCorruptos.Add(
"Error de integridad en la tabla -" + nombreTabla + "-. DVV vertical corrupto");
}
}
}
}
catch (Exception ex)
{
Logger.Log.Error("Error al validar la integridad de la base.", ex);
resultado.RegistrosCorruptos.Add("No se pudo validar la integridad de la base.");
resultado.EsValida = false;
return(resultado);
}
return(resultado);
}
/// <summary>
/// Borra un DVV.
/// </summary>
/// <param name="pDVV">DVV.</param>
/// <returns></returns>
public ResultadoBd Borrar(BE.DVV pDVV)
{
return(_accesoBaseDeDatos.Borrar(pDVV));
}
/// <summary>
/// Actualiza un DVV.
/// </summary>
/// <param name="pDVV">DVV.</param>
/// <returns></returns>
public ResultadoBd Actualizar(BE.DVV pDVV)
{
return(_accesoBaseDeDatos.Actualizar(pDVV));
}
/// <summary>
/// Inserta un DVV.
/// </summary>
/// <param name="pDVV">DVV.</param>
/// <returns></returns>
public ResultadoBd Insertar(BE.DVV pDVV)
{
return(_accesoBaseDeDatos.Insertar(pDVV));
}
