/// <summary>
/// Método para obtener las marcas registradas delimitadas por el paginador.
/// </summary>
/// <param name="pagina"> Información del filtro del paginador </param>
/// <param name="filtro"> Información del filtro de la marca </param>
/// <returns></returns>
public ResultadoInfo <MarcasInfo> ObtenerPorPagina(PaginacionInfo pagina, MarcasInfo filtro)
{
try
{
Dictionary <string, object> parameters = AuxMarcasDAL.ObtenerParametrosPorPagina(pagina, filtro);
DataSet ds = Retrieve("Marcas_ObtenerPorPagina", parameters);
ResultadoInfo <MarcasInfo> lista = null;
if (ValidateDataSet(ds))
{
lista = MapMarcasDAL.ObtenerPorPagina(ds);
}
return(lista);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que se utiliza para actualizar la información de una marca.
/// </summary>
/// <param name="marcasInfo"> Objeto con la información de la marca a guardar. </param>
/// <returns> Objeto con la información de la marca guardada. </returns>
public MarcasInfo ActualizarMarca(MarcasInfo marcasInfo)
{
try
{
Logger.Info();
var parameters = AuxMarcasDAL.ObtenerParametrosActualizarMarca(marcasInfo);
var ds = Retrieve("Marcas_ActualizaMarca", parameters);
if (ValidateDataSet(ds))
{
marcasInfo = MapMarcasDAL.ActulizarMarca(ds);
}
return(marcasInfo);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que selecciona una marca para comprobar para la existencia.
/// </summary>
/// <param name="marcasInfo"> Objeto con la información de la marca a buscar. </param>
/// <returns> Objeto con la información de la marca encontrada. </returns>
public MarcasInfo VerificaExistenciaMarca(MarcasInfo marcasInfo)
{
try
{
Logger.Info();
var parameters = AuxMarcasDAL.VerificaExistenciaMarca(marcasInfo);
marcasInfo = new MarcasInfo();
var ds = Retrieve("Marcas_VerificaExistenciaMarca", parameters);
if (ValidateDataSet(ds))
{
marcasInfo = MapMarcasDAL.VerificaExistenciaMarca(ds);
}
return(marcasInfo);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método para cargar el combo tipos de marcas
/// Recibe una parametro jaula info opcional
/// En caso de que jaula info sea null se mostrará
/// La opción seleccione
/// </summary>
private void CargarComboMarcas(JaulaInfo jaulaInfo = null)
{
try
{
var marcasPL = new MarcasPL();
var marcasInfo = new MarcasInfo();
IList <MarcasInfo> listaTiposMarcas = marcasPL.ObtenerMarcas(EstatusEnum.Inactivo, EstatusEnum.Activo);
if (listaTiposMarcas != null)
{
this.existenMarcas = true;
if (jaulaInfo == null)
{
marcasInfo = new MarcasInfo
{
MarcaId = 0,
Descripcion = Properties.Resources.JaulaEdicion_SeleccioneMarca
};
}
else
{
marcasInfo = new MarcasInfo
{
MarcaId = jaulaInfo.Marca == null ? 0 : jaulaInfo.Marca.MarcaId,
Descripcion = string.IsNullOrEmpty(jaulaInfo.Marca.Descripcion) ? Properties.Resources.JaulaEdicion_SeleccioneMarca : jaulaInfo.Marca.Descripcion
};
// Habilita campo de observaciones en modo de edición
// en caso de que la jaula tenga la opcion boletinado
if (jaulaInfo.Boletinado)
{
txtObservacionesRegistro.IsEnabled = true;
lblObservacionesRequerido.Visibility = Visibility.Visible;
}
}
listaTiposMarcas.Insert(0, marcasInfo);
cmbMarca.ItemsSource = listaTiposMarcas;
cmbMarca.SelectedItem = marcasInfo;
if (Contexto.Marca == null)
{
Contexto.Marca = marcasInfo;
}
else
{
Contexto.Marca.MarcaId = marcasInfo.MarcaId;
Contexto.Marca.Descripcion = marcasInfo.Descripcion;
}
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.JaulaEdicion_MsgMarcasActivas, MessageBoxButton.OK, MessageImage.Error);
this.existenMarcas = false;
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.JaulaEdicion_ErrorObtenerMarcas, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Método para cargar el combo tipos de organización
/// </summary>
private void CargarComboMarcas(CamionInfo camionInfo)
{
try{
var tipoMarcasPL = new MarcasPL();
IList <MarcasInfo> listaMarcas = tipoMarcasPL.ObtenerMarcas(EstatusEnum.Activo, EstatusEnum.Activo);
if (listaMarcas != null)
{
var tipoMarca = new MarcasInfo
{
MarcaId = (camionInfo.MarcaID == null) ? 0 : (int)camionInfo.MarcaID,
Descripcion = camionInfo.MarcaDescripcion,
};
if (tipoMarca.MarcaId == 0)
{
tipoMarca.Descripcion = Properties.Resources.Camion_MarcaSeleccionar;
listaMarcas.Insert(0, tipoMarca);
}
cmbMarca.ItemsSource = listaMarcas;
cmbMarca.SelectedItem = tipoMarca;
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_MarcasVacias, MessageBoxButton.OK, MessageImage.Error);
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Camion_ErrorEditar, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Método que se utiliza para guardar la información de una nueva marca.
/// </summary>
/// <param name="marcasInfo"> Objeto con la información de la marca a guardar. </param>
/// <returns> Objeto con la información de la marca guardada </returns>
public MarcasInfo GuardarMarca(MarcasInfo marcasInfo)
{
MarcasInfo result;
try
{
Logger.Info();
var marcasDAL = new MarcasDAL();
if (marcasInfo.MarcaId == 0)
{
result = marcasDAL.GuardarMarca(marcasInfo);
}
else
{
result = marcasDAL.ActualizarMarca(marcasInfo);
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Constructor por defecto
/// </summary>
public JaulaEdicion(ProveedorInfo proveedor, MarcasInfo marca = null)
{
InitializeComponent();
CargarAyudas();
CargarComboMarcas();
Contexto.Proveedor = proveedor;
Contexto.Marca = marca;
}
/// <summary>
/// Constructor para inicializar la pantalla con los datos de la marca a editar
/// </summary>
/// <param name="marcasInfo"> Información de las marcas a cargar en pantalla </param>
public MarcasEdicion(MarcasInfo marcasInfo)
{
InitializeComponent();
Contexto.Activo = marcasInfo.Activo;
Contexto.MarcaId = marcasInfo.MarcaId;
Contexto.Descripcion = marcasInfo.Descripcion;
rbTracto.IsChecked = Convert.ToBoolean(marcasInfo.EsTracto);
rbJaula.IsChecked = !Convert.ToBoolean(marcasInfo.EsTracto);
txtDescripcion.Focus();
}
/// <summary>
/// Inicializa el Contexto
/// </summary>
private void InicializaContexto()
{
ProveedorInfo proveedorInfo = (skAyudaProveedor != null && !skAyudaProveedor.IsEnabled) ? Contexto.Proveedor : new ProveedorInfo();
MarcasInfo marcasInfo = new MarcasInfo();
Contexto = new JaulaInfo
{
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
Proveedor = proveedorInfo,
Marca = marcasInfo
};
}
/// <summary>
/// Evento que se ejecuta al seleccionar el botón guardar.
/// </summary>
/// <param name="sender">Parámetro estandar sender</param>
/// <param name="e">Parámetro estandar e</param>
private void BtnGuardar_Click(object sender, RoutedEventArgs e)
{
try
{
if (Verificar())
{
var marcasInfo = new MarcasInfo()
{
MarcaId = Convert.ToInt32(txtMarcaID.Text),
Descripcion = txtDescripcion.Text.Trim(),
Activo = Convert.ToBoolean(cboEstatus.SelectedIndex) ? EstatusEnum.Activo : EstatusEnum.Inactivo,
UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
EsTracto = Convert.ToBoolean(rbTracto.IsChecked) ? TractoEnum.Tracto : TractoEnum.Jaula
};
var marcasPL = new MarcasPL();
MarcasInfo verificado = marcasPL.VerificaExistenciMarca(marcasInfo);
if (!(verificado.MarcaId > 0) || verificado.MarcaId == marcasInfo.MarcaId)
{
marcasInfo = marcasPL.GuardarMarca(marcasInfo);
if (marcasInfo.MarcaId != 0)
{
SkMessageBox.Show(this, Properties.Resources.MarcasEdicion_Mensaje_Exito, MessageBoxButton.OK, MessageImage.Correct);
if (marcasInfo.FechaModificacion == new DateTime())
{
LimpiarCampos();
}
else
{
confirmaSalir = false;
Close();
}
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.MarcasEdicion_Mensaje_Error, MessageBoxButton.OK, MessageImage.Error);
}
}
else
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.MarcasEdicion_Mensaje_MarcaRegistrada + verificado.MarcaId, MessageBoxButton.OK, MessageImage.Error);
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], ex.Message, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Evento que se ejecuta al cerrar la ventana
/// </summary>
/// <param name="e"> Parámetro estandar e </param>
protected override void OnClosing(CancelEventArgs e)
{
if (confirmaSalir)
{
MessageBoxResult result = SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Msg_CerrarSinGuardar, MessageBoxButton.YesNo,
MessageImage.Question);
if (result == MessageBoxResult.Yes)
{
Contexto = null;
}
else
{
e.Cancel = true;
}
}
}
/// <summary>
/// Método que obtiene la lista de todos las marcas registrados con ayuda el paginador
/// </summary>
/// <param name="inicio"> Número de inicio para la busqueda de registro </param>
/// <param name="limite"> Tope de busqueda de registros </param>
private void ObtenerListaMarcas(int inicio, int limite)
{
try
{
if (ucPaginacion.ContextoAnterior != null)
{
bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
if (!contextosIguales)
{
ucPaginacion.Inicio = 1;
inicio = 1;
}
}
var marcasPL = new MarcasPL();
var pagina = new PaginacionInfo {
Inicio = inicio, Limite = limite
};
var filtro = new MarcasInfo()
{
Activo = Convert.ToBoolean(cboEstatus.SelectedItem) ? EstatusEnum.Activo : EstatusEnum.Inactivo, Descripcion = txtDescripcion.Text
};
ResultadoInfo <MarcasInfo> resultadoInfo = marcasPL.ObtenerPorPagina(pagina, filtro);
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 <Marcas>();
}
}
catch (ExcepcionGenerica)
{
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Marcas_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Marcas_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Obtiene los parametros para el metodo de VerificaExistenciaMarca
/// </summary>
/// <param name="marcaInfo"> Objeto con los parametros </param>
/// <returns> Lista de parametros </returns>
internal static Dictionary <string, object> VerificaExistenciaMarca(MarcasInfo marcaInfo)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@Descripcion", marcaInfo.Descripcion },
{ "@Tracto", marcaInfo.EsTracto }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que se utiliza para comprobar que no exista la marca antes de guardarla
/// </summary>
/// <param name="marcasInfo"> Objeto con la información de la marca. </param>
/// <returns> Información de la marca en caso de encontrarla </returns>
public MarcasInfo VerificaExistenciMarca(MarcasInfo marcasInfo)
{
try
{
Logger.Info();
var marcasBL = new MarcasBL();
marcasInfo = marcasBL.VerificaExistenciaMarca(marcasInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(marcasInfo);
}
/// <summary>
/// Método que se utiliza para obtener los registros de marcas filtrados por el paginador
/// </summary>
/// <param name="pagina"> Informacion del filtro del paginador </param>
/// <param name="filtro"> Objeto con la informacion del filtro de la marca. </param>
/// <returns> Lista de marcas encontradas </returns>
public ResultadoInfo <MarcasInfo> ObtenerPorPagina(PaginacionInfo pagina, MarcasInfo filtro)
{
ResultadoInfo <MarcasInfo> result;
try
{
Logger.Info();
var marcasBL = new MarcasBL();
result = marcasBL.ObtenerPorPagina(pagina, filtro);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Método utilizado para dar de alta una nueva marca
/// </summary>
/// <param name="marcasInfo"> Objeto con la información de la marca a guardar. </param>
/// <returns> Información de la marca guardada </returns>
public MarcasInfo GuardarMarca(MarcasInfo marcasInfo)
{
MarcasInfo result;
try
{
Logger.Info();
var marcasBL = new MarcasBL();
result = marcasBL.GuardarMarca(marcasInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Método para obtener los parametros para guardar marca
/// </summary>
/// <param name="marcaInfo"> Objeto con los parametros </param>
/// <returns> lista de los parametros </returns>
internal static Dictionary <string, object> ObtenerParametrosGuardarMarca(MarcasInfo marcaInfo)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@Descripcion", marcaInfo.Descripcion },
{ "@Activo", marcaInfo.Activo },
{ "@Tracto", marcaInfo.EsTracto },
{ "@UsuarioCreacionId", marcaInfo.UsuarioCreacionID },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que obtiene los parametros para obtener las marcas por paginador.
/// </summary>
/// <param name="pagina"> Objeto con los parametros del paginador </param>
/// <param name="filtro"> Objeto con los parametros de la marca </param>
/// <returns> Lista de parametros </returns>
internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, MarcasInfo filtro)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@Descripcion", filtro.Descripcion },
{ "@Activo", filtro.Activo },
{ "@Inicio", pagina.Inicio },
{ "@Limite", pagina.Limite }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Método que inicializa el contexto de la interfaz.
/// </summary>
private void InicializaContexto()
{
Contexto = new MarcasInfo();
}
