/// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <ChoferInfo> ObtenerPorPagina(PaginacionInfo pagina, ChoferInfo filtro)
        {
            ResultadoInfo <ChoferInfo> result;

            try
            {
                Logger.Info();
                var chofervigilanciaBL = new ChoferVigilanciaBL();
                result = chofervigilanciaBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <IndicadorProductoBoletaInfo> ObtenerPorPagina(PaginacionInfo pagina,
                                                                     IndicadorProductoBoletaInfo filtro)
 {
     try
     {
         Logger.Info();
         var indicadorProductoBoletaDAL = new IndicadorProductoBoletaDAL();
         ResultadoInfo <IndicadorProductoBoletaInfo> result = indicadorProductoBoletaDAL.ObtenerPorPagina(pagina,
                                                                                                          filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, TratamientoProductoInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@TratamientoProductoID", filtro.TratamientoProductoID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
        /// <summary>
        ///     Obtiene un lista paginada de organizaciones
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <VigilanciaInfo> ObtenerCamionPorPagina(PaginacionInfo pagina, VigilanciaInfo filtro)
        {
            ResultadoInfo <VigilanciaInfo> resultadoOrganizacion;

            try
            {
                Logger.Info();
                var placasvigilanciaBL = new PlacasVigilanciaBL();
                resultadoOrganizacion = placasvigilanciaBL.ObtenerCamionPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultadoOrganizacion);
        }
Exemple #5
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <SubFamiliaInfo> ObtenerPorPagina(PaginacionInfo pagina, SubFamiliaInfo filtro)
        {
            ResultadoInfo <SubFamiliaInfo> resultado;

            try
            {
                Logger.Info();
                var subFamiliaBL = new SubFamiliaBL();
                resultado = subFamiliaBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Exemple #6
0
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, TipoMovimientoInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Descripcion", string.IsNullOrWhiteSpace(filtro.Descripcion) ? string.Empty : 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);
     }
 }
Exemple #7
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <TipoProrrateoInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoProrrateoInfo filtro)
        {
            ResultadoInfo <TipoProrrateoInfo> costoLista;

            try
            {
                Logger.Info();
                var tipoProrrateoDAL = new TipoProrrateoDAL();
                costoLista = tipoProrrateoDAL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(costoLista);
        }
Exemple #8
0
        /// <summary>
        /// Obtiene un lista paginada de Alertas para el modulo ConfiguracionAlertas para la ayuda de Alertas
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns>una lista de folios del dia</returns>
        public ResultadoInfo <AlertaInfo> ObtenerPorPaginaAlertas(PaginacionInfo pagina, AlertaInfo filtro)
        {
            ResultadoInfo <AlertaInfo> resultadoAlertas;

            try
            {
                Logger.Info();
                var configAlertasBl = new ConfiguracionAlertasBL();
                resultadoAlertas = configAlertasBl.ObtenerPorPaginaAlertas(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultadoAlertas);
        }
Exemple #9
0
 /// <summary>
 /// Obtiene los productos filtrados por subfamilia y con paginación
 /// </summary>
 /// <param name="pagina"> Información de la paginación </param>
 /// <param name="filtro"> Información con la cual se realizará el filtrado </param>
 /// <returns></returns>
 public ResultadoInfo <ProductoInfo> ObtenerPorPaginaFiltroSubFamilia(PaginacionInfo pagina, ProductoInfo filtro)
 {
     try
     {
         Logger.Info();
         var productoBL = new ProductoBL();
         filtro.FamiliaId = 0;
         filtro.UnidadId  = 0;
         ResultadoInfo <ProductoInfo> result = productoBL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #10
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <TipoGanadoInfo> Centros_ObtenerPorPagina(PaginacionInfo pagina, TipoGanadoInfo filtro)
        {
            ResultadoInfo <TipoGanadoInfo> result;

            try
            {
                Logger.Info();
                var tipoGanadoBL = new TipoGanadoBL();
                result = tipoGanadoBL.Centros_ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
Exemple #11
0
        /// <summary>
        /// Obtiene un lista paginada de los folios de salida
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <SalidaProductoInfo> ObtenerFolioPorPaginaReimpresion(PaginacionInfo pagina, SalidaProductoInfo filtro)
        {
            ResultadoInfo <SalidaProductoInfo> foliosLista = null;

            try
            {
                Dictionary <string, object> parameters =
                    AuxSalidaProductoDAL.ObtenerParametrosPorPaginaReimpresion(pagina, filtro);
                using (IDataReader reader = RetrieveReader("SalidaProducto_ObtenerFolioPorPaginaReimpresion", parameters))
                {
                    if (ValidateDataReader(reader))
                    {
                        foliosLista = MapSalidaProductoDAL.ObtenerFoliosPorPaginaReimpresion(reader);
                    }
                }
            }
            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);
            }
            finally
            {
                if (Connection.State == ConnectionState.Open)
                {
                    Connection.Close();
                }
            }
            return(foliosLista);
        }
Exemple #12
0
 /// <summary>
 /// Obtiene la lista para mostrar en el grid
 /// </summary>
 private void ObtenerListaOperador(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var          operadorPL = new OperadorPL();
         OperadorInfo filtros    = ObtenerFiltros();
         var          pagina     = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <OperadorInfo> resultadoInfo = operadorPL.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 <Operador>();
         }
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Obtiene la lista para mostrar en el grid
 /// </summary>
 private void ObtenerListaObservacion(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var observacionPL = new ObservacionPL();
         var pagina        = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <ObservacionInfo> resultadoInfo = observacionPL.ObtenerPorPagina(pagina, Contexto);
         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 <Observacion>();
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Observacion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Observacion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
 }
Exemple #14
0
        internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, CamionInfo filtro, IList <IDictionary <IList <string>, object> > dependencias)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@PlacaCamion", filtro.PlacaCamion },
                    { "@Inicio", pagina.Inicio },
                    { "@Limite", pagina.Limite }
                };
                AuxDAL.ObtenerDependencias(parametros, dependencias);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(parametros);
        }
Exemple #15
0
        public ResultadoInfo <CostoInfo> ObtenerPorDescripcionTipoCosto(PaginacionInfo pagina, string descripcion)
        {
            ResultadoInfo <CostoInfo> resultado;

            try
            {
                var costo = new CostoInfo {
                    Descripcion = descripcion, Activo = EstatusEnum.Activo
                };
                resultado = ObtenerPorPaginaTipoCosto(pagina, costo);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Exemple #16
0
        /// <summary>
        ///     Obtiene un lista paginada de organizaciones
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <param name="dependencias"> </param>
        /// <returns></returns>
        public ResultadoInfo <OrganizacionInfo> ObtenerPorPaginaOrigenID(PaginacionInfo pagina, OrganizacionInfo filtro
                                                                         , IList <IDictionary <IList <String>, Object> > dependencias)
        {
            ResultadoInfo <OrganizacionInfo> resultadoOrganizacion;

            try
            {
                Logger.Info();
                var organizacionBL = new OrganizacionBL();
                resultadoOrganizacion = organizacionBL.ObtenerPorPaginaOrigenID(pagina, filtro, dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultadoOrganizacion);
        }
Exemple #17
0
        /// <summary>
        /// Obtiene pedidos por pagina
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="pedido"></param>
        /// <returns></returns>
        internal ResultadoInfo <PedidoInfo> ObtenerPedidosCompletoPaginado(PaginacionInfo pagina, PedidoInfo pedido)
        {
            ResultadoInfo <PedidoInfo> resultado = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parametros = AuxPedidoDAL.ObtenerParametrosPedidoCompletoPaginado(pagina,
                                                                                                              pedido);
                DataSet ds = Retrieve("Pedido_ObtenerPorPaginaRecibido", parametros);
                if (ValidateDataSet(ds))
                {
                    resultado = MapPedidosDAL.ObtenerPedidoCompletoPaginado(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Exemple #18
0
        /// <summary>
        ///     Obtiene un lista paginada de Empelados
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <EmpleadoInfo> ObtenerPorPagina(PaginacionInfo pagina, EmpleadoInfo filtro)
        {
            ResultadoInfo <EmpleadoInfo> resultado;

            try
            {
                Logger.Info();
                resultado = new ResultadoInfo <EmpleadoInfo>();
                var bl = new EmpleadoBL();
                resultado = bl.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, MermaSuperavitInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@AlmacenID", filtro.Almacen.AlmacenID },
             { "@OrganizacionID", filtro.Almacen.Organizacion.OrganizacionID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #20
0
        /// <summary>
        /// Obtiene una lista paginada de ClaseCostoProducto
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <ClaseCostoProductoInfo> ObtenerPorPagina(PaginacionInfo pagina, ClaseCostoProductoInfo filtro)
        {
            try
            {
                Logger.Info();
                var result    = new ResultadoInfo <ClaseCostoProductoInfo>();
                var condicion = da.Tabla <ClaseCostoProductoInfo>().Where(e => e.Activo == filtro.Activo);
                if (filtro.ClaseCostoProductoID > 0)
                {
                    condicion = condicion.Where(e => e.ClaseCostoProductoID == filtro.ClaseCostoProductoID);
                }

                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.ClaseCostoProductoID)
                               .Skip((inicio - 1) * limite)
                               .Take(limite);

                result.Lista = paginado.ToList();

                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Exemple #21
0
 /// <summary>
 /// Obtiene los parametros por familia
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerPorFamiliaPaginado(PaginacionInfo pagina, ProductoInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@FamiliaID", filtro.Familia.FamiliaID },
             { "@Descripcion", filtro.ProductoDescripcion },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #22
0
 internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, PrecioProductoInfo filtros)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@OrganizacionID", filtros.Organizacion.OrganizacionID },
             { "@ProductoDescripcion", filtros.Producto.ProductoDescripcion },
             { "@Activo", filtros.Activo.GetHashCode() },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #23
0
        public ResultadoInfo <ClienteCreditoExcelInfo> ObtenerPorPagina(PaginacionInfo pagina, ClienteCreditoExcelInfo filtro)
        {
            ResultadoInfo <ClienteCreditoExcelInfo> resultado;

            try
            {
                Logger.Info();
                var clienteCreditoExcelBL = new ClienteCreditoExcelBL();
                resultado = clienteCreditoExcelBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Exemple #24
0
 internal ResultadoInfo <ProveedorInfo> ObtenerPorDescripcion(PaginacionInfo pagina, string descripcion)
 {
     try
     {
         Logger.Info();
         var proveedorDAL = new ProveedorDAL();
         var filtro       = new ProveedorInfo {
             Descripcion = descripcion, CodigoSAP = string.Empty, Activo = EstatusEnum.Activo
         };
         ResultadoInfo <ProveedorInfo> result = proveedorDAL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #25
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, CuentaAlmacenSubFamiliaInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@CuentaAlmacenSubFamiliaID", filtro.CuentaAlmacenSubFamiliaID },
             { "@AlmacenID", filtro.Almacen.AlmacenID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #26
0
        /// <summary>
        ///     Obtiene un lista paginada de organizaciones
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <param name="dependencias"> </param>
        /// <returns></returns>
        internal ResultadoInfo <VigilanciaInfo> ObtenerPorDependencias(PaginacionInfo pagina, VigilanciaInfo filtro
                                                                       , IList <IDictionary <IList <String>, Object> > dependencias)
        {
            ResultadoInfo <VigilanciaInfo> resultadoOrganizacion;

            try
            {
                Logger.Info();
                var transportistavigilanciaDAL = new TransportistaVigilanciaDAL();
                resultadoOrganizacion = transportistavigilanciaDAL.ObtenerPorDependencias(pagina, filtro, dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultadoOrganizacion);
        }
        /// <summary>
        /// Obtiene parametros para obtener lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, VigilanciaInfo filtro)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@ID", filtro.ID },
                    { "@Descripcion", filtro.Descripcion },
                    { "@Inicio", pagina.Inicio },
                    { "@Limite", pagina.Limite },
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(parametros);
        }
Exemple #28
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <param name="Dependencias"> </param>
        /// <returns></returns>
        public ResultadoInfo <CamionInfo> ObtenerPorPagina(PaginacionInfo pagina, CamionInfo filtro
                                                           , IList <IDictionary <IList <string>, object> > Dependencias)
        {
            ResultadoInfo <CamionInfo> result;

            try
            {
                Logger.Info();
                var camionBL = new CamionBL();
                result = camionBL.ObtenerPorPagina(pagina, filtro, Dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
Exemple #29
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, IndicadorInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@IndicadorID", filtro.IndicadorId },
             { "@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);
     }
 }
        public static IList <FormulaInfo> ObtenerFormulaPagina(string descripcionFormula)
        {
            var pagina = new PaginacionInfo
            {
                Inicio = 1,
                Limite = 100000
            };
            var formulaPL = new FormulaPL();
            var formula   = new FormulaInfo
            {
                Descripcion = descripcionFormula,
                Activo      = EstatusEnum.Activo
            };
            ResultadoInfo <FormulaInfo> formulas = formulaPL.ObtenerPorPaseCalidadPaginado(pagina, formula);
            var resultado = new List <FormulaInfo>();

            if (formulas != null)
            {
                resultado.AddRange(formulas.Lista);
            }
            return(resultado);
        }