/// <summary>
/// Metodo para Guardar/Modificar una entidad ProblemaSintoma
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public int Guardar(ProblemaSintomaInfo info)
{
try
{
Logger.Info();
var id = 0;
if (info.ProblemaSintomaID > 0)
{
id = da.Actualizar <ProblemaSintomaInfo>(info);
problemaSintomaAccessor.ActualizarFechaModificacion(info.ProblemaSintomaID);
}
else
{
id = da.Insertar <ProblemaSintomaInfo>(info);
}
return(id);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad ProblemaSintoma
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public void Guardar(ProblemaSintomaInfo info)
{
try
{
Logger.Info();
List <ProblemaSintomaInfo> listaGuardar = ArmarListaGuardar(info);
using (TransactionScope transaction = new TransactionScope())
{
foreach (var problemaSintomaInfo in listaGuardar)
{
problemaSintomaDAL.Guardar(problemaSintomaInfo);
}
transaction.Complete();
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private void BotonEditar_Click(object sender, RoutedEventArgs e)
{
try
{
var btn = (Button)e.Source;
var sintomaEditar = (SintomaInfo)btn.CommandParameter;
var problemaSintomaEditar = new ProblemaSintomaInfo
{
Sintoma = new SintomaInfo
{
SintomaID = sintomaEditar.SintomaID,
Descripcion = sintomaEditar.Descripcion,
Activo = sintomaEditar.Activo,
HabilitaEdicion = false
}
};
var sintomaOriginal = (SintomaInfo)Extensor.ClonarInfo(sintomaEditar);
var problemaSintomaEdicionSintoma =
new ProblemaSintomaEdicionSintoma(problemaSintomaEditar)
{
ucTitulo = { TextoTitulo = Properties.Resources.ProblemaSintomaEdicion_Edicion }
};
MostrarCentrado(problemaSintomaEdicionSintoma);
ReiniciarValoresPaginador();
if (problemaSintomaEdicionSintoma.ConfirmaSalir)
{
var sintomaModificado =
Contexto.ListaSintomas.FirstOrDefault(
sinto => sinto.SintomaID == sintomaOriginal.SintomaID);
if (sintomaModificado == null)
{
return;
}
sintomaModificado.Activo = sintomaOriginal.Activo;
gridDatosSintoma.ItemsSource = null;
gridDatosSintoma.ItemsSource = resultadoInfo.Lista;
}
else
{
var sintomaModificado =
Contexto.ListaSintomas.FirstOrDefault(
sinto => sinto.SintomaID == sintomaOriginal.SintomaID);
if (sintomaModificado == null)
{
return;
}
sintomaModificado.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
sintomaModificado.Activo = problemaSintomaEditar.Sintoma.Activo;
gridDatosSintoma.ItemsSource = null;
gridDatosSintoma.ItemsSource = resultadoInfo.Lista;
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(this, Properties.Resources.TratamiendoEdicion_ErrorEditar, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
Contexto = new ProblemaSintomaInfo
{
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Problema = new ProblemaInfo
{
TipoProblema = new TipoProblemaInfo()
}
};
}
/// <summary>
/// Constructor parametrizado
/// </summary>
public ProblemaSintomaEdicionSintoma(ProblemaSintomaInfo problemaSintoma)
{
try
{
InitializeComponent();
ProblemaSintoma = problemaSintoma;
}
catch (Exception ex)
{
Logger.Error(ex);
//SkMessageBox.Show(this, Properties.Resources.ProblemaSintomaEdicionSintoma_ErrorInicial, MessageBoxButton.OK, MessageImage.Error);
}
}
private void BotonNuevoSintoma_Click(object sender, RoutedEventArgs e)
{
var problemaSintoma = new ProblemaSintomaInfo
{
Sintoma = new SintomaInfo
{
HabilitaEdicion = true,
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado()
},
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado()
};
var problemaSintomaEdicionSintoma = new ProblemaSintomaEdicionSintoma(problemaSintoma)
{
ucTitulo = { TextoTitulo = Properties.Resources.ProblemaSintomaEdicion_Nuevo }
};
MostrarCentrado(problemaSintomaEdicionSintoma);
ReiniciarValoresPaginador();
if (problemaSintomaEdicionSintoma.ConfirmaSalir)
{
return;
}
if (problemaSintoma.Sintoma != null && problemaSintoma.Sintoma.SintomaID != 0)
{
var sintomaRepetido =
Contexto.ListaSintomas.FirstOrDefault(
sinto => sinto.SintomaID == problemaSintoma.Sintoma.SintomaID);
if (sintomaRepetido != null)
{
SkMessageBox.Show(this, Properties.Resources.ProblemaSintomaEdicion_SintomaRepetido,
MessageBoxButton.OK, MessageImage.Warning);
return;
}
int ordenMaximo = 0;
if (Contexto.ListaSintomas.Any())
{
ordenMaximo = Contexto.ListaSintomas.Max(sinto => sinto.Orden);
}
problemaSintoma.Sintoma.UsuarioCreacionID = problemaSintoma.UsuarioCreacionID;
problemaSintoma.Sintoma.Orden = ordenMaximo + 1;
Contexto.ListaSintomas.Add(problemaSintoma.Sintoma);
resultadoInfo.Lista.Add(problemaSintoma.Sintoma);
gridDatosSintoma.ItemsSource = null;
gridDatosSintoma.ItemsSource = resultadoInfo.Lista;
resultadoInfo.TotalRegistros = Contexto.ListaSintomas.Count;
ucPaginacionSintoma.TotalRegistros = resultadoInfo.TotalRegistros;
}
}
private List <ProblemaSintomaInfo> ArmarListaGuardar(ProblemaSintomaInfo info)
{
var listaGuardar = (from prob in info.ListaSintomas
where prob.ProblemaSintomaID == 0 || (prob.ProblemaSintomaID > 0 && prob.UsuarioModificacionID != null)
select new ProblemaSintomaInfo
{
ProblemaSintomaID = prob.ProblemaSintomaID,
ProblemaID = info.ProblemaID,
SintomaID = prob.SintomaID,
Activo = prob.Activo,
UsuarioCreacionID = prob.UsuarioCreacionID,
UsuarioModificacionID = prob.UsuarioModificacionID
}).ToList();
return(listaGuardar);
}
/// <summary>
/// Constructor para editar una entidad ProblemaSintoma Existente
/// </summary>
/// <param name="problemaSintomaInfo"></param>
public ProblemaSintomaEdicion(ProblemaSintomaInfo problemaSintomaInfo)
{
InitializeComponent();
problemaSintomaInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
CargaComboTipoProblema();
Contexto = problemaSintomaInfo;
if (Contexto.ListaSintomas != null && Contexto.ListaSintomas.Any())
{
int ordenSecuencia = 0;
Contexto.ListaSintomas.ForEach(sintoma =>
{
ordenSecuencia = ordenSecuencia + 1;
sintoma.Orden = ordenSecuencia;
});
}
}
/// <summary>
/// Evento que se ejecuta mientras se esta cerrando la ventana
/// </summary>
/// <param name="e"></param>
protected override void OnClosing(CancelEventArgs e)
{
if (confirmaSalir)
{
MessageBoxResult result = SkMessageBox.Show(this, Properties.Resources.Msg_CerrarSinGuardar,
MessageBoxButton.YesNo,
MessageImage.Question);
if (result == MessageBoxResult.Yes)
{
Contexto = null;
}
else
{
e.Cancel = true;
}
}
}
/// <summary>
/// Obtiene la lista para mostrar en el grid
/// </summary>
private void ObtenerListaProblemaSintoma(int inicio, int limite)
{
try
{
var problemaSintomaBL = new ProblemaSintomaBL();
ProblemaSintomaInfo filtros = ObtenerFiltros();
if (ucPaginacion.ContextoAnterior != null)
{
bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
if (!contextosIguales)
{
ucPaginacion.Inicio = 1;
inicio = 1;
}
}
var pagina = new PaginacionInfo {
Inicio = inicio, Limite = limite
};
ResultadoInfo <ProblemaSintomaInfo> resultadoInfo = problemaSintomaBL.ObtenerPorPagina(pagina, filtros);
if (resultadoInfo != null && resultadoInfo.Lista != null &&
resultadoInfo.Lista.Count > 0)
{
gridDatos.ItemsSource = resultadoInfo.Lista;
ucPaginacion.TotalRegistros = resultadoInfo.TotalRegistros;
}
else
{
ucPaginacion.TotalRegistros = 0;
gridDatos.ItemsSource = new List <ProblemaSintoma>();
}
}
catch (ExcepcionGenerica)
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.ProblemaSintoma_ErrorBuscar, MessageBoxButton.OK,
MessageImage.Error);
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.ProblemaSintoma_ErrorBuscar, MessageBoxButton.OK,
MessageImage.Error);
}
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void ObtenerListaSintomas(ProblemaSintomaInfo problemaSintomaSeleccionado)
{
var problemaSintomaBL = new ProblemaSintomaBL();
var listaProblemasSintoma = problemaSintomaBL.ObtenerProblemasSintomaTodos();
var sintomas = (from sinto in listaProblemasSintoma
where sinto.ProblemaID == problemaSintomaSeleccionado.ProblemaID
select new SintomaInfo
{
SintomaID = sinto.SintomaID,
Descripcion = sinto.Sintoma.Descripcion,
Activo = sinto.Activo,
ProblemaSintomaID = sinto.ProblemaSintomaID,
UsuarioCreacionID = sinto.UsuarioCreacionID,
UsuarioModificacionID = sinto.UsuarioModificacionID
}).ToList();
problemaSintomaSeleccionado.ListaSintomas = sintomas;
}
/// <summary>
/// Obtiene una entidad de ProblemaSintoma por su ProblemaID y su SintomaID
/// </summary>
/// <param name="filtro">parametro que contiene los filtros de busqueda del Problema Sintoma</param>
/// <returns></returns>
public ProblemaSintomaInfo ObtenerPorProblemaSintoma(ProblemaSintomaInfo filtro)
{
try
{
Logger.Info();
return
(problemaSintomaDAL.ObtenerTodos().FirstOrDefault(
pro => pro.ProblemaID == filtro.ProblemaID && pro.SintomaID == filtro.SintomaID));
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una lista paginada de ProblemaSintoma
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <returns></returns>
public ResultadoInfo <ProblemaSintomaInfo> ObtenerPorPagina(PaginacionInfo pagina, ProblemaSintomaInfo filtro)
{
try
{
Logger.Info();
ResultadoInfo <ProblemaSintomaInfo> result = new ResultadoInfo <ProblemaSintomaInfo>();
var condicion = da.Tabla <ProblemaSintomaInfo>().Where(e => e.Activo == filtro.Activo);
if (filtro.ProblemaSintomaID > 0)
{
condicion = condicion.Where(e => e.ProblemaSintomaID == filtro.ProblemaSintomaID);
}
if (filtro.Problema != null && filtro.Problema.ProblemaID > 0)
{
condicion = condicion.Where(e => e.ProblemaID == filtro.Problema.ProblemaID);
}
if ((filtro.Problema != null && filtro.Problema.TipoProblema != null) && filtro.Problema.TipoProblema.TipoProblemaId > 0)
{
condicion = (from con in condicion
join pro in da.Tabla <ProblemaInfo>() on con.ProblemaID equals pro.ProblemaID
where pro.TipoProblemaID == filtro.Problema.TipoProblema.TipoProblemaId
select con);
}
result.TotalRegistros = condicion.Count();
int inicio = pagina.Inicio;
int limite = pagina.Limite;
if (inicio > 1)
{
int limiteReal = (limite - inicio) + 1;
inicio = (limite / limiteReal);
limite = limiteReal;
}
var paginado = condicion
.OrderBy(e => e.ProblemaID)
.Skip((inicio - 1) * limite)
.Take(limite).ToList();
CargarProblemas(paginado);
CargarSintomas(paginado);
result.Lista = paginado;
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una lista paginada de ProblemaSintoma
/// </summary>
/// <param name="pagina"></param>
/// <param name="filtro"></param>
/// <returns></returns>
public ResultadoInfo <ProblemaSintomaInfo> ObtenerPorPagina(PaginacionInfo pagina, ProblemaSintomaInfo filtro)
{
try
{
Logger.Info();
return(problemaSintomaDAL.ObtenerPorPagina(pagina, filtro));
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
