/// <summary>
        ///     Obtiene una lista de las Rutas
        /// </summary>
        /// <returns></returns>
        internal List <ConfiguracionEmbarqueDetalleInfo> ObtenerRutasPorDescripcion(ConfiguracionEmbarqueInfo filtro)
        {
            List <ConfiguracionEmbarqueDetalleInfo> result = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters = AuxConfiguracionEmbarqueDAL.ObtenerParametrosRutasPorDescripcion(filtro);
                DataSet ds = Retrieve("[dbo].[ProgramacionEmbarque_ObtenerRutaPorOrigenDestino]", parameters);
                if (ValidateDataSet(ds))
                {
                    result = MapConfiguracionEmbarqueDAL.ObtenerRutasPorDescripcion(ds);
                }
            }
            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);
            }
            return(result);
        }
        /// <summary>
        ///     Obtiene parametros para actualizar
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosActualizar(ConfiguracionEmbarqueInfo info)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@ConfiguracionEmbarqueID", info.ConfiguracionEmbarqueID },
                    { "@OrganizacionOrigenID", info.OrganizacionOrigen.OrganizacionID },
                    { "@OrganizacionDestinoID", info.OrganizacionDestino.OrganizacionID },
                    { "@Kilometros", info.Kilometros },
                    { "@Horas", info.Horas },
                    { "@Activo", info.Activo },
                    { "@UsuarioModificacionID", info.UsuarioModificacionID },
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(parametros);
        }
        /// <summary>
        ///     Obtiene la configuración de embarque
        /// </summary>
        /// <param name="organizacionOrigenId">Organización origen de la configuración</param>
        /// <param name="organizacionDestinoId">Organización destino de la configuración</param>
        /// <returns></returns>
        internal ConfiguracionEmbarqueInfo ObtenerPorOrganizacion(int organizacionOrigenId, int organizacionDestinoId)
        {
            ConfiguracionEmbarqueInfo result = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters = AuxConfiguracionEmbarqueDAL.ObtenerParametrosPorOrganizacion(organizacionOrigenId, organizacionDestinoId);
                DataSet ds = Retrieve("[dbo].[ConfiguracionEmbarque_ObtenerPorOrganizacion]", parameters);
                if (ValidateDataSet(ds))
                {
                    result = MapConfiguracionEmbarqueDAL.ObtenerPorID(ds);
                }
            }
            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);
            }
            return(result);
        }
예제 #4
0
        public static List <ConfiguracionEmbarqueDetalleInfo> ObtenerRutasPorId(ConfiguracionEmbarqueInfo embarque)
        {
            List <ConfiguracionEmbarqueDetalleInfo> listaRutasPorId = null;

            try
            {
                var configuracionEmbarquePL = new ConfiguracionEmbarquePL();
                embarque.Activo = EstatusEnum.Activo;
                var seguridad = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;

                if (seguridad != null)
                {
                    listaRutasPorId = (List <ConfiguracionEmbarqueDetalleInfo>)configuracionEmbarquePL.ObtenerRutasPorId(embarque);

                    if (embarque.ConfiguracionEmbarqueDetalle.ConfiguracionEmbarqueDetalleID > 0 && listaRutasPorId != null)
                    {
                        //Filtra todas las rutas que contengan lo capturado
                        listaRutasPorId = listaRutasPorId.Where(
                            registro => registro.ConfiguracionEmbarqueDetalleID == embarque.ConfiguracionEmbarqueDetalle.ConfiguracionEmbarqueDetalleID).ToList();
                    }
                }
            }
            catch (ExcepcionDesconocida)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(listaRutasPorId);
        }
예제 #5
0
 /// <summary>
 ///     Metodo que guarda un ConfiguracionEmbarque
 /// </summary>
 /// <param name="info"></param>
 internal void Guardar(ConfiguracionEmbarqueInfo info)
 {
     try
     {
         Logger.Info();
         var configuracionEmbarqueDAL = new ConfiguracionEmbarqueDAL();
         if (info.ConfiguracionEmbarqueID != 0)
         {
             configuracionEmbarqueDAL.Actualizar(info);
         }
         else
         {
             configuracionEmbarqueDAL.Crear(info);
         }
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #6
0
        /// <summary>
        /// Constructor para editar una entidad ConfiguracionEmbarque Existente
        /// </summary>
        /// <param name="configuracionEmbarqueInfo"></param>
        public ConfiguracionEmbarqueEdicion(ConfiguracionEmbarqueInfo configuracionEmbarqueInfo)
        {
            InitializeComponent();
            configuracionEmbarqueInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
            Contexto = configuracionEmbarqueInfo;

            CargarAyudas();
        }
예제 #7
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ConfiguracionEmbarqueInfo
     {
         OrganizacionOrigen  = new OrganizacionInfo(),
         OrganizacionDestino = new OrganizacionInfo(),
         UsuarioCreacionID   = AuxConfiguracion.ObtenerUsuarioLogueado(),
         Activo = EstatusEnum.Activo
     };
 }
예제 #8
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ConfiguracionEmbarqueInfo
     {
         OrganizacionOrigen = new OrganizacionInfo
         {
             TipoOrganizacion = new TipoOrganizacionInfo()
         },
         OrganizacionDestino = new OrganizacionInfo
         {
             TipoOrganizacion = new TipoOrganizacionInfo()
         },
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado()
     };
 }
예제 #9
0
 /// <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>
 ///     Metodo que guarda un ConfiguracionEmbarque
 /// </summary>
 /// <param name="info"></param>
 public void Guardar(ConfiguracionEmbarqueInfo info)
 {
     try
     {
         Logger.Info();
         var configuracionEmbarqueBL = new ConfiguracionEmbarqueBL();
         configuracionEmbarqueBL.Guardar(info);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #11
0
 /// <summary>
 /// Obtiene la lista de las Rutas
 /// </summary>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public List <ConfiguracionEmbarqueDetalleInfo> ObtenerRutasPorDescripcion(ConfiguracionEmbarqueInfo filtro)
 {
     try
     {
         Logger.Info();
         var configuracionEmbarqueBL = new ConfiguracionEmbarqueBL();
         List <ConfiguracionEmbarqueDetalleInfo> lista = configuracionEmbarqueBL.ObtenerRutasPorDescripcion(filtro);
         return(lista);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #12
0
        /// <summary>
        /// Obtiene la lista para mostrar en el grid
        /// </summary>
        private void ObtenerListaConfiguracionEmbarque(int inicio, int limite)
        {
            try
            {
                if (ucPaginacion.ContextoAnterior != null)
                {
                    bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
                    if (!contextosIguales)
                    {
                        ucPaginacion.Inicio = 1;
                        inicio = 1;
                    }
                }

                var configuracionEmbarquePL       = new ConfiguracionEmbarquePL();
                ConfiguracionEmbarqueInfo filtros = ObtenerFiltros();
                var pagina = new PaginacionInfo {
                    Inicio = inicio, Limite = limite
                };
                ResultadoInfo <ConfiguracionEmbarqueInfo> resultadoInfo = configuracionEmbarquePL.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 <ConfiguracionEmbarque>();
                }
            }
            catch (ExcepcionGenerica)
            {
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.ConfiguracionEmbarque_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.ConfiguracionEmbarque_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
            }
        }
예제 #13
0
        /// <summary>
        ///     Obtiene la lista de las Rutas filtrado por Origen y Destino
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal List <ConfiguracionEmbarqueDetalleInfo> ObtenerRutasPorDescripcion(ConfiguracionEmbarqueInfo filtro)
        {
            List <ConfiguracionEmbarqueDetalleInfo> result;

            try
            {
                Logger.Info();
                var configuracionEmbarqueDAL = new ConfiguracionEmbarqueDAL();
                result = configuracionEmbarqueDAL.ObtenerRutasPorDescripcion(filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
 /// <summary>
 /// Obtiene parametros para obtener una lista de las Rutas
 /// </summary>
 /// /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerRutasPorId(ConfiguracionEmbarqueInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ConfiguracionEmbarqueDetalleID", filtro.ConfiguracionEmbarqueDetalle.ConfiguracionEmbarqueDetalleID },
             { "@OrigenID", filtro.OrganizacionOrigen.OrganizacionID },
             { "@DestinoID", filtro.OrganizacionDestino.OrganizacionID },
             { "@Activo", filtro.Activo.GetHashCode() },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #15
0
 /// <summary>
 ///     Metodo que actualiza un ConfiguracionEmbarque
 /// </summary>
 /// <param name="info"></param>
 internal void Actualizar(ConfiguracionEmbarqueInfo info)
 {
     try
     {
         Dictionary <string, object> parameters = AuxConfiguracionEmbarqueDAL.ObtenerParametrosActualizar(info);
         Update("ConfiguracionEmbarque_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 un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <ConfiguracionEmbarqueInfo> ObtenerPorPagina(PaginacionInfo pagina, ConfiguracionEmbarqueInfo filtro)
        {
            ResultadoInfo <ConfiguracionEmbarqueInfo> result;

            try
            {
                Logger.Info();
                var configuracionEmbarqueBL = new ConfiguracionEmbarqueBL();
                result = configuracionEmbarqueBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
예제 #17
0
        public static List <ConfiguracionEmbarqueDetalleInfo> ObtenerRutasPorDescripcion(string descripcion, ConfiguracionEmbarqueInfo embarque)
        {
            List <ConfiguracionEmbarqueDetalleInfo> listaRutasDescripcion = null;

            try
            {
                var configuracionEmbarquePL = new ConfiguracionEmbarquePL();
                embarque.Activo = EstatusEnum.Activo;
                var seguridad = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;

                if (seguridad != null)
                {
                    listaRutasDescripcion = (List <ConfiguracionEmbarqueDetalleInfo>)configuracionEmbarquePL.ObtenerRutasPorDescripcion(embarque);

                    if (descripcion.Length > 0 && listaRutasDescripcion != null)
                    {
                        //Filtra todas las rutas que contengan lo capturado
                        listaRutasDescripcion = listaRutasDescripcion.Where(
                            registro => registro.Descripcion.ToString(CultureInfo.InvariantCulture).ToUpper()
                            .Contains(descripcion.ToString(CultureInfo.InvariantCulture).ToUpper())).ToList();
                    }
                }
            }
            catch (ExcepcionDesconocida)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(listaRutasDescripcion);
        }
 /// <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, ConfiguracionEmbarqueInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ConfiguracionEmbarqueID", filtro.ConfiguracionEmbarqueID },
             { "@OrganizacionOrigenID", filtro.OrganizacionOrigen.OrganizacionID },
             { "@OrganizacionDestinoID", filtro.OrganizacionDestino.OrganizacionID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #19
0
        /// <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(skAyudaOrigen.Clave) ||
                    string.IsNullOrWhiteSpace(skAyudaOrigen.Descripcion) ||
                    skAyudaOrigen.Clave == "0")
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConfiguracionEmbarqueEdicion_MsgOrganizacionOrigen;
                    skAyudaOrigen.AsignarFoco();
                }
                else if (string.IsNullOrWhiteSpace(skAyudaDestino.Clave) ||
                         string.IsNullOrWhiteSpace(skAyudaDestino.Descripcion) ||
                         skAyudaDestino.Clave == "0")
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConfiguracionEmbarqueEdicion_MsgOrganizacionDestino;
                    skAyudaDestino.AsignarFoco();
                }
                else if (skAyudaOrigen.Clave == skAyudaDestino.Clave)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ProgramacionEmbarque_DestinoIgualOrigen;
                    txtConfiguracionEmbarqueId.Focus();
                    var tRequest = new TraversalRequest(FocusNavigationDirection.Next);
                    txtConfiguracionEmbarqueId.MoveFocus(tRequest);
                }
                else if (!dtuKilometros.Value.HasValue || string.IsNullOrWhiteSpace(dtuKilometros.Text) ||
                         dtuKilometros.Text == "0")
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConfiguracionEmbarqueEdicion_MsgKilometrosRequerida;
                    dtuKilometros.Focus();
                }
                else if (!dtuHoras.Value.HasValue || string.IsNullOrWhiteSpace(dtuHoras.Text) ||
                         dtuHoras.Text == "0.0")
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConfiguracionEmbarqueEdicion_MsgHorasRequerida;
                    dtuHoras.Focus();
                }
                else
                {
                    int configuracionEmbarqueId = Extensor.ValorEntero(txtConfiguracionEmbarqueId.Text);
                    int organizacionOrigenId    = Extensor.ValorEntero(skAyudaOrigen.Clave);
                    int organizacionDestinoId   = Extensor.ValorEntero(skAyudaDestino.Clave);

                    var configuracionEmbarquePL = new ConfiguracionEmbarquePL();
                    ConfiguracionEmbarqueInfo configuracionEmbarque =
                        configuracionEmbarquePL.ObtenerPorOrganizacion(organizacionOrigenId,
                                                                       organizacionDestinoId);

                    if (configuracionEmbarque != null &&
                        (configuracionEmbarqueId == 0 ||
                         configuracionEmbarqueId != configuracionEmbarque.ConfiguracionEmbarqueID))
                    {
                        resultado = false;
                        mensaje   =
                            string.Format(
                                Properties.Resources.ConfiguracionEmbarqueEdicion_MsgConfiguracionExistente,
                                configuracionEmbarque.ConfiguracionEmbarqueID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
예제 #20
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <ConfiguracionEmbarqueInfo> ObtenerPorPagina(PaginacionInfo pagina, ConfiguracionEmbarqueInfo filtro)
        {
            ResultadoInfo <ConfiguracionEmbarqueInfo> lista = null;

            try
            {
                Dictionary <string, object> parameters = AuxConfiguracionEmbarqueDAL.ObtenerParametrosPorPagina(pagina, filtro);
                DataSet ds = Retrieve("ConfiguracionEmbarque_ObtenerPorPagina", parameters);
                if (ValidateDataSet(ds))
                {
                    lista = MapConfiguracionEmbarqueDAL.ObtenerPorPagina(ds);
                }
            }
            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);
            }
            return(lista);
        }