示例#1
0
 /// <summary>
 /// Metodo para Crear un registro de Roladora
 /// </summary>
 /// <param name="info">Valores de la entidad que será creada</param>
 public int Crear(RoladoraInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxRoladoraDAL.ObtenerParametrosCrear(info);
         int result = Create("Roladora_Crear", parameters);
         return(result);
     }
     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);
     }
 }
示例#2
0
 /// <summary>
 /// Obtiene un registro de Roladora
 /// </summary>
 /// <param name="descripcion">Descripción de la Roladora</param>
 /// <returns></returns>
 public RoladoraInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxRoladoraDAL.ObtenerParametrosPorDescripcion(descripcion);
         DataSet      ds     = Retrieve("Roladora_ObtenerPorDescripcion", parameters);
         RoladoraInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapRoladoraDAL.ObtenerPorDescripcion(ds);
         }
         return(result);
     }
     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);
     }
 }
示例#3
0
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 public static RoladoraInfo ObtenerPorID(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable    dt      = ds.Tables[ConstantesDAL.DtDatos];
         RoladoraInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new RoladoraInfo
         {
             RoladoraID = info.Field <int>("RoladoraID"),
             Organizacion = new OrganizacionInfo {
                 OrganizacionID = info.Field <int>("OrganizacionID"), Descripcion = info.Field <string>("Organizacion")
             },
             Descripcion = info.Field <string>("Descripcion"),
             Activo = info.Field <bool>("Activo").BoolAEnum(),
         }).First();
         return(entidad);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#4
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new RoladoraInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
示例#5
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad Roladora
 /// </summary>
 /// <param name="info"></param>
 /// <returns></returns>
 public int Guardar(RoladoraInfo info)
 {
     try
     {
         Logger.Info();
         var id = 0;
         if (info.RoladoraID > 0)
         {
             id = da.Actualizar <RoladoraInfo>(info);
             roladoraAccessor.ActualizarFechaModificacion(info.RoladoraID);
         }
         else
         {
             id = da.Insertar <RoladoraInfo>(info);
         }
         return(id);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#6
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <RoladoraInfo> ObtenerPorPagina(PaginacionInfo pagina, RoladoraInfo filtro)
 {
     try
     {
         Dictionary <string, object> parameters = AuxRoladoraDAL.ObtenerParametrosPorPagina(pagina, filtro);
         DataSet ds = Retrieve("Roladora_ObtenerPorPagina", parameters);
         ResultadoInfo <RoladoraInfo> result = null;
         if (ValidateDataSet(ds))
         {
             result = MapRoladoraDAL.ObtenerPorPagina(ds);
         }
         return(result);
     }
     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);
     }
 }
示例#7
0
 /// <summary>
 ///  Obtiene parametros para actualizar
 /// </summary>
 /// <param name="info">Valores de la entidad</param>
 /// <returns></returns>
 public static Dictionary <string, object> ObtenerParametrosActualizar(RoladoraInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Activo", info.Activo },
             { "@Activo", info.Activo },
             { "@Descripcion", info.Descripcion },
             { "@Activo", info.Activo },
             { "@RoladoraID", info.RoladoraID },
             { "@OrganizacionID", info.Organizacion.OrganizacionID },
             { "@Descripcion", info.Descripcion },
             { "@Activo", info.Activo },
             { "@UsuarioModificacionID", info.UsuarioModificacionID },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
        /// <summary>
        /// Metodo que valida los datos para guardar
        /// </summary>
        /// <returns></returns>
        private bool ValidaGuardar()
        {
            bool   resultado = true;
            string mensaje   = string.Empty;

            try
            {
                if (string.IsNullOrWhiteSpace(txtRoladoraID.Text))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.RoladoraEdicion_MsgRoladoraIDRequerida;
                    txtRoladoraID.Focus();
                }
                else if (Contexto.Organizacion == null || Contexto.Organizacion.OrganizacionID == 0)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.RoladoraEdicion_MsgOrganizacionIDRequerida;
                    skAyudaOrganizacion.AsignarFoco();
                }
                else if (string.IsNullOrWhiteSpace(txtDescripcion.Text) || Contexto.Descripcion == string.Empty)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.RoladoraEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else if (cmbActivo.SelectedItem == null)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.RoladoraEdicion_MsgActivoRequerida;
                    cmbActivo.Focus();
                }
                else
                {
                    int    roladoraId  = Extensor.ValorEntero(txtRoladoraID.Text);
                    string descripcion = txtDescripcion.Text;

                    var          roladoraPL = new RoladoraBL();
                    RoladoraInfo roladora   = roladoraPL.ObtenerPorDescripcion(descripcion);

                    if (roladora != null && (roladoraId == 0 || roladoraId != roladora.RoladoraID))
                    {
                        resultado = false;
                        mensaje   = string.Format(Properties.Resources.RoladoraEdicion_MsgDescripcionExistente, roladora.RoladoraID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
 /// <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;
         }
     }
 }
示例#10
0
        /// <summary>
        /// Obtiene una lista paginada de Roladora
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <RoladoraInfo> ObtenerPorPagina(PaginacionInfo pagina, RoladoraInfo filtro)
        {
            try
            {
                Logger.Info();
                ResultadoInfo <RoladoraInfo> result = new ResultadoInfo <RoladoraInfo>();
                var condicion = da.Tabla <RoladoraInfo>().Where(e => e.Activo == filtro.Activo);
                if (filtro.RoladoraID > 0)
                {
                    condicion = condicion.Where(e => e.RoladoraID == filtro.RoladoraID);
                }
                if (!string.IsNullOrEmpty(filtro.Descripcion))
                {
                    condicion = condicion.Where(e => e.Descripcion.Contains(filtro.Descripcion));
                }
                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.Descripcion)
                               .Skip((inicio - 1) * limite)
                               .Take(limite);

                result.Lista = paginado.ToList();

                CargarOrganizaciones(result.Lista);

                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
示例#11
0
 /// <summary>
 /// Obtiene una lista paginada de Roladora
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <RoladoraInfo> ObtenerPorPagina(PaginacionInfo pagina, RoladoraInfo filtro)
 {
     try
     {
         Logger.Info();
         return(roladoraDAL.ObtenerPorPagina(pagina, filtro));
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#12
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad Roladora
 /// </summary>
 /// <param name="info"></param>
 /// <returns></returns>
 public int Guardar(RoladoraInfo info)
 {
     try
     {
         Logger.Info();
         return(roladoraDAL.Guardar(info));
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#13
0
 /// <summary>
 /// Obtiene la lista para mostrar en el grid
 /// </summary>
 private void ObtenerListaRoladora(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var          roladoraPL = new RoladoraBL();
         RoladoraInfo filtros    = ObtenerFiltros();
         var          pagina     = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <RoladoraInfo> resultadoInfo = roladoraPL.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;
             ucPaginacion.AsignarValoresIniciales();
             gridDatos.ItemsSource = new List <Roladora>();
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Roladora_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Roladora_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
 }
示例#14
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new RoladoraInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
         Organizacion      = new OrganizacionInfo
         {
             TipoOrganizacion = new TipoOrganizacionInfo
             {
                 TipoOrganizacionID = Services.Info.Enums.TipoOrganizacion.Ganadera.GetHashCode()
             },
             ListaTiposOrganizacion = new List <TipoOrganizacionInfo>
             {
                 new TipoOrganizacionInfo
                 {
                     TipoOrganizacionID = Services.Info.Enums.TipoOrganizacion.Ganadera.GetHashCode()
                 }
             }
         }
     };
 }
示例#15
0
 /// <summary>
 /// Metodo para actualizar un registro de Roladora
 /// </summary>
 /// <param name="info">Valores de la entidad que se actualizarán</param>
 public void Actualizar(RoladoraInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxRoladoraDAL.ObtenerParametrosActualizar(info);
         Update("Roladora_Actualizar", parameters);
     }
     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);
     }
 }
示例#16
0
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, RoladoraInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@RoladoraID", filtro.RoladoraID },
             { "@Descripcion", filtro.Descripcion },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#17
0
 /// <summary>
 /// Constructor para editar una entidad Roladora Existente
 /// </summary>
 /// <param name="roladoraInfo"></param>
 public RoladoraEdicion(RoladoraInfo roladoraInfo)
 {
     InitializeComponent();
     roladoraInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
     Contexto = roladoraInfo;
 }