/// <summary>
/// Actualiza a un usuario.
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Usuarios a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Usuarios> userL = new List<Entidades.Usuarios>();
userL = Datos.Seguridad.Usuarios.Obtener(new Entidades.Usuarios() { IdPersona = a.IdPersona });
var validarDatos = from l in userL
where l.IdUsuario != a.IdUsuario
select l;
userL = validarDatos.ToList();
if (userL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Ya existe un usuario asignado para esta persona.";
resultado.errores.Add(error);
}
userL = Datos.Seguridad.Usuarios.Obtener(new Entidades.Usuarios() { Usuario = a.Usuario });
validarDatos = from l in userL
where l.IdUsuario != a.IdUsuario
select l;
userL = validarDatos.ToList();
if (userL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Ya existe un usuario con el mismo alias.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
if (a.IdPersona.IdPersona == -1)
{
a.IdPersona = null;
}
resultado.resultado = Datos.Seguridad.Usuarios.actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Usuario actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Proceso no completado correctamente.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Método para actualizar un rol.
/// </summary>
/// <param name="a"></param>
/// <param name="mrL"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.RolUsuario a, List<Entidades.MenuXrol> mrL)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
List<Entidades.RolUsuario> RolLista = new List<Entidades.RolUsuario>();
RolLista = Datos.Seguridad.RolUsuario.Obtener(new Entidades.RolUsuario() { NombreRol = a.NombreRol });
var validarNombre = from l in RolLista
where l.IdRol != a.IdRol
select l;
RolLista = validarNombre.ToList();
if (RolLista.Count == 0)
{
resultado.resultado = Datos.Seguridad.RolUsuario.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Rol actualizado correctamente.";
resultado.errores.Add(error);
List<Entidades.MenuXrol> _mrL = new List<Entidades.MenuXrol>();
_mrL = Datos.Seguridad.MenuXrol.Obtener(new Entidades.MenuXrol() { IdRol = new Entidades.RolUsuario() { IdRol = a.IdRol } });
if (_mrL.Count > 0)
{
resultado.resultado = Datos.Seguridad.MenuXrol.Eliminar(_mrL);
}
resultado.resultado = Datos.Seguridad.MenuXrol.Nuevo(mrL);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Menus actualizados correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Menus no actualizados, proceso no se completo correctamente.";
resultado.errores.Add(error);
}
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "No se realizo actualización de rol, proceso no ejecutado correctamente.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Método para actualizar los datos de una persona, no se permiten duplicados.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Personas a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Personas> perL = new List<Entidades.Personas>();
perL = Datos.Seguridad.Personas.Obtener(new Entidades.Personas() { Nombre = a.Nombre });
var validarDatos = from l in perL
where l.IdPersona != a.IdPersona
select l;
perL = validarDatos.ToList();
if (perL.Count > 0)
{
resultado.resultado = false;
}
perL = Datos.Seguridad.Personas.Obtener(new Entidades.Personas() { Correo = a.Correo });
validarDatos = from l in perL
where l.IdPersona != a.IdPersona
select l;
perL = validarDatos.ToList();
if (perL.Count > 0)
{
resultado.resultado = false;
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Seguridad.Personas.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Persona actualizada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Proceso no compleatado, vuelva a intentar por favor.";
resultado.errores.Add(error);
}
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Persona y/o correo duplicado.";
resultado.errores.Add(error);
}
return resultado;
}
public static Entidades.Logica.Ejecucion Eliminar(Entidades.MarcaServidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
//consultar idMarcaservidor en Soporte y Modelos.
List<Entidades.Modelo> modeloL = new List<Entidades.Modelo>();
modeloL = Datos.Catalogos.Modelo.Obtener(new Entidades.Modelo() { IdMarca = a.IdMarca });
if(modeloL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Hay modelos ligados a esta marca, no se puede realizar esta acción.";
resultado.errores.Add(error);
}
List<Entidades.Soporte> soporteL = new List<Entidades.Soporte>();
soporteL = Datos.Inventarios.Soporte.Obtener(new Entidades.Soporte() { IdModelo = a.IdMarca });
if(soporteL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 4;
error.descripcionCorta = "Hay un soporte ligado a esta marca, no se puede realizar esta acción.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.MarcaServidor.Eliminar(a);
if(resultado.resultado==true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Marca eliminada.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Error en la operacion, el proceso no pudo continuar.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro de Configuración de red.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.ConfRed a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.ConfRed> consultaRed = new List<Entidades.ConfRed>();
consultaRed = Datos.Inventarios.ConfRed.Obtener(new Entidades.ConfRed() { DirIP = a.DirIP, MascaraSubRed = a.MascaraSubRed });
var red = from l in consultaRed
where l.IdConfRed != a.IdConfRed
select l;
consultaRed = red.ToList();
if (consultaRed.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Dirección de IP duplicada.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Inventarios.ConfRed.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Configuración de red actualizada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en Servidor.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Servidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Servidor> servidorL = new List<Entidades.Servidor>();
servidorL = Datos.Inventarios.Servidor.Obtener(new Entidades.Servidor() { AliasServidor = a.AliasServidor });
var validarDatos = from l in servidorL
where l.IdServidor != a.IdServidor
select l;
servidorL = validarDatos.ToList();
if (servidorL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Ya existe este alias asociado a un servidor.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Inventarios.Servidor.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Servidor actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en Almacenamiento.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Soporte a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Soporte> sop = new List<Entidades.Soporte>();
sop = Datos.Inventarios.Soporte.Obtener(new Entidades.Soporte()
{
Modelo = new Entidades.Modelo() { IdModelo = a.Modelo.IdModelo },
Empresa = null
});
var dis = from s in sop
where s.IdSoporte != a.IdSoporte
select s;
sop = dis.ToList();
if (sop.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Este modelo ya tiene soporte.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Inventarios.Soporte.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Soporte actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registo en TipoArregloDisco.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.TipoArregloDisco a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.TipoArregloDisco> tiposL = new List<Entidades.TipoArregloDisco>();
tiposL = Datos.Catalogos.TipoArregloDisco.Obtener(new Entidades.TipoArregloDisco() { Tipo = a.Tipo });
var validarDatos = from l in tiposL
where l.IdTipoArreglo != a.IdTipoArreglo
select l;
tiposL = validarDatos.ToList();
if (tiposL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Este tipo de disco ya esta registrado.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoArregloDisco.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de disco actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en TipoMemoria
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.TipoMemoria a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.TipoMemoria> tipomL = new List<Entidades.TipoMemoria>();
tipomL = Datos.Catalogos.TipoMemoria.Obtener(new Entidades.TipoMemoria() { Tipo = a.Tipo });
var validarDatos = from l in tipomL
where l.IdTipoMemoria != a.IdTipoMemoria
select l;
tipomL = validarDatos.ToList();
if (tipomL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe un tipo de memoria con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoMemoria.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de memoria actualizada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no cmpletado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registo en Procesador.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Procesador a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Procesador> procesadorL = new List<Entidades.Procesador>();
procesadorL = Datos.Catalogos.Procesador.Obtener(new Entidades.Procesador() { Nombre = a.Nombre });
var validarDatos = from l in procesadorL
where l.IdProcesador != a.IdProcesador
select l;
procesadorL = validarDatos.ToList();
if (procesadorL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe un procesador con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Procesador.Nuevo(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Procesador almacenado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en Modelo.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Modelo a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Modelo> modeloL = new List<Entidades.Modelo>();
modeloL = Datos.Catalogos.Modelo.Obtener(new Entidades.Modelo() { NombreModelo = a.NombreModelo });
var validarDatos = from l in modeloL
where l.IdModelo != a.IdModelo
select l;
modeloL = validarDatos.ToList();
if (modeloL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe una marca con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Modelo.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Modelo actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en Estatus.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Estatus a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Estatus> estatusL = new List<Entidades.Estatus>();
estatusL = Datos.Catalogos.Estatus.Obtener(new Entidades.Estatus() { _Estatus = a._Estatus });
var validarDatos = from l in estatusL
where l.IdEstatus != a.IdEstatus
select l;
estatusL = validarDatos.ToList();
if (estatusL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Y existe un estatus con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Estatus.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Estatus almacenado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registo existente en ConceptoEstatus
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.ConceptoEstatus a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.ConceptoEstatus> conceptosL = new List<Entidades.ConceptoEstatus>();
conceptosL = Datos.Catalogos.ConceptoEstatus.Obtener(new Entidades.ConceptoEstatus() { Concepto = a.Concepto });
var validarDatos = from l in conceptosL
where l.IdConceptoEstatus != a.IdConceptoEstatus
select l;
conceptosL = validarDatos.ToList();
if (conceptosL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe un concepto con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.ConceptoEstatus.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Concepto actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "El proceso no se completo.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en TipoStorage.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.TipoStorage a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error = new Entidades.Logica.Error();
resultado.resultado = true;
List<Entidades.TipoStorage> storageL = new List<Entidades.TipoStorage>();
storageL = Datos.Catalogos.TipoStorage.Obtener(new Entidades.TipoStorage() { Tipo = a.Tipo });
var validarDatos = from l in storageL
where l.IdTipoStorage != a.IdTipoStorage
select l;
storageL = validarDatos.ToList();
if (storageL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe un Tipo de storage con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoStorage.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de storage actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registro en SO.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.SO a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.SO> soL = new List<Entidades.SO>();
soL = Datos.Catalogos.SO.Obtener(new Entidades.SO() { NombreSO = a.NombreSO });
var validarDatos = from l in soL
where l.IdSO != a.IdSO
select l;
soL = validarDatos.ToList();
if (soL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe un SO con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.SO.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "SO actualizado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Actualiza un registo de Empresa.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Actualizar(Entidades.Empresa a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Empresa> empresaL = new List<Entidades.Empresa>();
empresaL = Datos.Catalogos.Empresa.Obtener(new Entidades.Empresa() { Nombre = a.Nombre });
var validarDatos = from l in empresaL
where l.IdEmpresa != a.IdEmpresa
select l;
empresaL = validarDatos.ToList();
if (empresaL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Ya existe una empresa con el mismo nombre.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Empresa.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Empresa actualizada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
public static Entidades.Logica.Ejecucion Actualizar(Entidades.MarcaServidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.MarcaServidor> marcaL = new List<Entidades.MarcaServidor>();
marcaL = Datos.Catalogos.MarcaServidor.ObtenerMarcaServidor(new Entidades.MarcaServidor() { NombreMarca = a.NombreMarca });
var validarDatos = from l in marcaL
where l.IdMarca != a.IdMarca
select l;
marcaL = validarDatos.ToList();
if (marcaL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Esta marca ya se encuentra en el catalogo.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.MarcaServidor.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Marca actualizada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Esta marca ya se encuentra en el catalogo.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro de Modelo.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.Modelo a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Servidor> servidorL = new List<Entidades.Servidor>();
servidorL = Datos.Inventarios.Servidor.Obtener(new Entidades.Servidor() { Modelo = new Entidades.Modelo() { IdModelo = a.IdModelo } });
if (servidorL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Hay servidores con este modelo, no puede eliminarse.";
resultado.errores.Add(error);
}
if (resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Modelo.Eliminar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Empresa eliminada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro de TipoArregloDisco
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.TipoArregloDisco a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.EspServidor> especificacionL = new List<Entidades.EspServidor>();
especificacionL = Datos.Inventarios.EspServidor.Obtener(new Entidades.EspServidor() { IdTipoArreglo = a.IdTipoArreglo });
if(especificacionL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Hay servidores con este tipo de arreglo de disco.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoArregloDisco.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Tipo de arreglo eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro en Procesador.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.Procesador a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.EspServidor> especificacionL = new List<Entidades.EspServidor>();
especificacionL = Datos.Inventarios.EspServidor.Obtener(new Entidades.EspServidor() { IdProcesador = a.IdProcesador });
if(especificacionL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Existen especificacines de servidor con este procesador, no puede eliminarse.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Procesador.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Procesador eliminado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro de Empresa
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.Empresa a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Soporte> soporteL = new List<Entidades.Soporte>();
soporteL = Datos.Inventarios.Soporte.Obtener(new Entidades.Soporte() { IdEmpresa = a.IdEmpresa });
if(soporteL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Hay marcas con soporte de esta empresa, no se puede eliminar.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.Empresa.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Empresa eliminada correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina el registro de Configuración de red.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.EspServidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Servidor> servL = new List<Entidades.Servidor>();
servL = Datos.Inventarios.Servidor.Obtener(new Entidades.Servidor() { Especificacion=new Entidades.EspServidor() { IdEspecificacion = a.IdEspecificacion } });
if(servL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Esta especificación esta asignada a al servidor, no puede eliminarse.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Inventarios.EspServidor.Eliminar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Especificación eliminada.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro en TipoMemoria.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.TipoMemoria a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Almacenamiento> almacenamientoL = new List<Entidades.Almacenamiento>();
almacenamientoL = Datos.Inventarios.Almacenamiento.Obtener(new Entidades.Almacenamiento() { IdTipoMemoria = a.IdTipoMemoria });
if(almacenamientoL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Hay seridores con este tipo de almacenamiento, no se puede eliminar.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoMemoria.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de almacenamiento guardado corectamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registo de SO.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.SO a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.SOxServidor> soSerL = new List<Entidades.SOxServidor>();
soSerL = Datos.Inventarios.SOxServidor.Obtener(new Entidades.SOxServidor() { IdSO = a.IdSO });
if(soSerL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Hay servidores que tienen este SO, no se puede eliminar.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.SO.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "SO eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro en TipoServidor.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.TipoServidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Servidor> servL = new List<Entidades.Servidor>();
servL = Datos.Inventarios.Servidor.Obtener(new Entidades.Servidor() { TipoServidor = new Entidades.TipoServidor() { IdTipoServidor = a.IdTipoServidor } });
if(servL.Count > 0)
{
resultado.resultado = true;
error = new Entidades.Logica.Error();
error.idError = 0;
error.descripcionCorta = "Hay servidores que son de este tipo, no se puede eliminar.";
resultado.errores.Add(error);
}
if( resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.TipoServidor.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de servidor eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Proceso no completado";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registo de ConceptoEstatus
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.ConceptoEstatus a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Estatus> estatusL = new List<Entidades.Estatus>();
estatusL = Datos.Catalogos.Estatus.Obtener(new Entidades.Estatus() { IdConceptoEstatus = a.IdConceptoEstatus });
if (estatusL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Existe un estatus con este concepto, no se puede eliminar.";
resultado.errores.Add(error);
}
if(resultado.resultado == true)
{
resultado.resultado = Datos.Catalogos.ConceptoEstatus.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Concepto eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "El proceso no se completo.";
resultado.errores.Add(error);
}
}
return resultado;
}
/// <summary>
/// Elimina un registro en TipoStorage.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.TipoStorage a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = true;
List<Entidades.Storage> storageL = new List<Entidades.Storage>();
storageL = Datos.Inventarios.Storage.Obtener(new Entidades.Storage() { IdTipoStorage = a.IdTipoStorage });
if(storageL.Count > 0)
{
resultado.resultado = false;
error = new Entidades.Logica.Error();
error.idError = 3;
error.descripcionCorta = "Hay servidores con este tipo de storage asingnado, no se puede eliminar.";
resultado.errores.Add(error);
}
if(resultado.resultado == true )
{
resultado.resultado = Datos.Catalogos.TipoStorage.Eliminar(a);
if(resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Tipo de storage eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
}
return resultado;
}
public static Entidades.Logica.Ejecucion Actualizar(Entidades.BitacoraMantenimiento a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = Datos.Bitacoras.BitacoraMantenimiento.Actualizar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Se actualizo el registro en la bitacora de operaciones correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Ocurrio un problema para registra el evento en la bitacora, proceso no concluido.";
resultado.errores.Add(error);
}
return resultado;
}
/// <summary>
/// Elimina el registro en PersonaXservidor.
/// </summary>
/// <param name="a"></param>
/// <returns>Entidades.Logica.Ejecucion</returns>
public static Entidades.Logica.Ejecucion Eliminar(Entidades.Almacenamiento a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = Datos.Inventarios.Almacenamiento.Eliminar(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Registro eliminado.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
return resultado;
}
/// <summary>
/// Registra un nuevo registro en PersonaXservidor.
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public static Entidades.Logica.Ejecucion Nuevo(Entidades.PersonaXservidor a)
{
Entidades.Logica.Ejecucion resultado = new Entidades.Logica.Ejecucion();
Entidades.Logica.Error error;
resultado.resultado = Datos.Inventarios.PersonaXservidor.Nuevo(a);
if (resultado.resultado == true)
{
error = new Entidades.Logica.Error();
error.idError = 1;
error.descripcionCorta = "Transaccion se ha registrado correctamente.";
resultado.errores.Add(error);
}
else
{
error = new Entidades.Logica.Error();
error.idError = 2;
error.descripcionCorta = "Proceso no completado.";
resultado.errores.Add(error);
}
return resultado;
}
