/// <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(); }