/// <summary>
        /// Agrega ayuda costos
        /// </summary>
        private void AgregarAyudaCosto()
        {
            var tipoCosto = new TipoCostoInfo()
            {
                TipoCostoID = (int)TipoCostoEnum.Flete,
                Activo      = EstatusEnum.Activo
            };
            var listaTipoCosto = new List <TipoCostoInfo> {
                tipoCosto
            };

            skAyudaCostos = new SKAyuda <CostoInfo>(200, false, new CostoInfo {
                ListaTipoCostos = listaTipoCosto
            }
                                                    , "PropiedadClaveRegistrarProgramacionInternaFletes"
                                                    , "PropiedadDescripcionRegistrarProgramacionInternaFletes", true)
            {
                AyudaPL = new CostoPL(),
                MensajeClaveInexistente = Properties.Resources.RegistrarProgramacionFletesInterna_CodigoInvalido,
                MensajeBusquedaCerrar   = Properties.Resources.RegistrarProgramacionFletesInterna_SalirSinSeleccionar,
                MensajeBusqueda         = Properties.Resources.AyudaCostos_Busqueda,
                MensajeAgregar          = Properties.Resources.RegistrarProgramacionFletesInterna_Seleccionar,
                TituloEtiqueta          = Properties.Resources.AyudaCostos_LeyendaBusqueda,
                TituloPantalla          = Properties.Resources.AyudaCostos_BusquedaTitulo,
            };
            skAyudaCostos.ObtenerDatos += ObtenerDatosCostos;
            SplAyudaCostos.Children.Clear();
            SplAyudaCostos.Children.Add(skAyudaCostos);
        }
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new TipoCostoInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
Esempio n. 3
0
        /// <summary>
        ///     Metodo que crear un Tipo Costo
        /// </summary>
        /// <param name="info"></param>
        internal int Crear(TipoCostoInfo info)
        {
            int infoId;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters = AuxTipoCostoDAL.ObtenerParametrosGuardado(info);
                infoId = Create("[dbo].[TipoCosto_Crear]", 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);
            }

            return(infoId);
        }
Esempio n. 4
0
        /// <summary>
        ///     Obtiene un TipoCostoInfo por Id
        /// </summary>
        /// <param name="infoId"></param>
        /// <returns></returns>
        internal TipoCostoInfo ObtenerPorID(int infoId)
        {
            TipoCostoInfo result = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters = AuxTipoCostoDAL.ObtenerParametroPorID(infoId);
                DataSet ds = Retrieve("[dbo].[TipoCosto_ObtenerPorID]", parameters);
                if (ValidateDataSet(ds))
                {
                    result = MapTipoCostoDAL.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);
        }
Esempio n. 5
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad TipoCosto
 /// </summary>
 /// <param name="info"></param>
 internal int Guardar(TipoCostoInfo info)
 {
     try
     {
         Logger.Info();
         var tipoCostoDAL = new TipoCostoDAL();
         int result       = info.TipoCostoID;
         if (info.TipoCostoID == 0)
         {
             result = tipoCostoDAL.Crear(info);
         }
         else
         {
             tipoCostoDAL.Actualizar(info);
         }
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 6
0
        public void ObtenerTipoCostoPorId()
        {
            var           tipoCostoPL = new TipoCostoPL();
            TipoCostoInfo tipoCosto   = tipoCostoPL.ObtenerPorID(1);

            Assert.IsNotNull(tipoCosto);
            Assert.IsTrue(tipoCosto.Descripcion.Length > 0);
        }
Esempio n. 7
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new TipoCostoInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
         Descripcion       = string.Empty
     };
 }
Esempio n. 8
0
        /// <summary>
        /// Cambiar leyenda de Todos por Seleccione
        /// </summary>
        private void CambiarLeyendaCombo()
        {
            TipoCostoInfo tipoCosto =
                Contexto.ListaTipoCostos.FirstOrDefault(desc => desc.Descripcion.Equals(Properties.Resources.cbo_Seleccione));

            if (tipoCosto != null)
            {
                tipoCosto.Descripcion = Properties.Resources.cbo_Seleccionar;
            }
        }
Esempio n. 9
0
        /// <summary>
        /// Agrega un elemento a lista de costo
        /// en la posicion cero
        /// </summary>
        private void AgregarElementoInicialTiposCosto(IList <TipoCostoInfo> tiposCosto)
        {
            var tipoCostoInicial = new TipoCostoInfo
            {
                TipoCostoID = 0, Descripcion = Properties.Resources.cbo_Seleccionar
            };

            if (!tiposCosto.Contains(tipoCostoInicial))
            {
                tiposCosto.Insert(0, tipoCostoInicial);
            }
        }
Esempio n. 10
0
        /// <summary>
        /// Asigna valores al contexto despues
        /// de que se realice un guardado
        /// </summary>
        /// <param name="contextoClone"></param>
        private void AsignarValoresContexto(CostoInfo contextoClone)
        {
            if (contextoClone != null)
            {
                Contexto.ListaRetencion        = contextoClone.ListaRetencion;
                Contexto.ListaTipoCostos       = contextoClone.ListaTipoCostos;
                Contexto.ListaTipoProrrateo    = contextoClone.ListaTipoProrrateo;
                Contexto.ListaTipoCostoCentro  = contextoClone.ListaTipoCostoCentro;
                Contexto.UsuarioCreacionID     = contextoClone.UsuarioCreacionID;
                Contexto.UsuarioModificacionID = contextoClone.UsuarioModificacionID;

                RetencionInfo retencion =
                    contextoClone.ListaRetencion.FirstOrDefault(ret => ret.RetencionID == 0);
                if (retencion != null)
                {
                    Contexto.Retencion = retencion;
                }

                TipoProrrateoInfo tipoProrrateo =
                    contextoClone.ListaTipoProrrateo.FirstOrDefault(tip => tip.TipoProrrateoID == 0);
                if (tipoProrrateo != null)
                {
                    Contexto.TipoProrrateo = tipoProrrateo;
                }

                TipoCostoInfo tipoCosto =
                    contextoClone.ListaTipoCostos.FirstOrDefault(costo => costo.TipoCostoID == 0);
                if (tipoCosto != null)
                {
                    Contexto.TipoCosto = tipoCosto;
                }

                TipoCostoCentroInfo tipoCostoCentro =
                    contextoClone.ListaTipoCostoCentro.FirstOrDefault(CostoCentro => CostoCentro.TipoCostoCentroID == 0);
                if (tipoCostoCentro != null)
                {
                    Contexto.TipoCostoCentro = tipoCostoCentro;
                }

                cboRetencion.ItemsSource       = Contexto.ListaRetencion;
                cboTipoCosto.ItemsSource       = Contexto.ListaTipoCostos;
                cboTipoProrrateo.ItemsSource   = Contexto.ListaTipoProrrateo;
                cboTipoCostoCentro.ItemsSource = Contexto.ListaTipoCostoCentro;

                cboTipoCosto.SelectedItem       = Contexto.TipoCosto;
                cboRetencion.SelectedItem       = Contexto.Retencion;
                cboTipoProrrateo.SelectedItem   = Contexto.TipoProrrateo;
                cboTipoCostoCentro.SelectedItem = Contexto.TipoCostoCentro;

                txtClaveContable.Focus();
            }
        }
Esempio n. 11
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;
         }
     }
 }
Esempio n. 12
0
        /// <summary>
        /// Obtiene la Depedencia por Costo
        /// </summary>
        /// <returns></returns>
        private IList <IDictionary <IList <string>, Object> > ObtenerDependenciasCosto()
        {
            IList <IDictionary <IList <string>, Object> > dependencias = new List <IDictionary <IList <string>, Object> >();
            IDictionary <IList <string>, Object>          dependecia   = new Dictionary <IList <string>, Object>();
            IList <string> camposDependientes = new List <string>();

            camposDependientes.Add("TipoCostoID");

            var tipoCostoInfo = new TipoCostoInfo {
                TipoCostoID = TipoCostoTraslado
            };

            dependecia.Add(camposDependientes, tipoCostoInfo);
            dependencias.Add(dependecia);

            return(dependencias);
        }
Esempio n. 13
0
 /// <summary>
 ///     Metodo que crear un Tipo Costo
 /// </summary>
 /// <param name="info"></param>
 public void Guardar(TipoCostoInfo info)
 {
     try
     {
         Logger.Info();
         var tipoCostoBL = new TipoCostoBL();
         tipoCostoBL.Guardar(info);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 14
0
 /// <summary>
 ///     Metodo que actualiza un Tipo Costo
 /// </summary>
 /// <param name="info"></param>
 internal void Actualizar(TipoCostoInfo info)
 {
     try
     {
         Logger.Info();
         var tipoCostosDAL = new TipoCostoDAL();
         tipoCostosDAL.Actualizar(info);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 15
0
 /// <summary>
 /// Obtiene una entidad por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 public TipoCostoInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var           tipoCostoBL = new TipoCostoBL();
         TipoCostoInfo result      = tipoCostoBL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 16
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <TipoCostoInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoCostoInfo filtro)
        {
            ResultadoInfo <TipoCostoInfo> result;

            try
            {
                Logger.Info();
                var tipoCostoBL = new TipoCostoBL();
                result = tipoCostoBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
Esempio n. 17
0
        /// <summary>
        ///     Obtiene parametros para crear
        /// </summary>
        /// <param name="tipoCostoInfo"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosGuardado(TipoCostoInfo tipoCostoInfo)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@Descripcion", tipoCostoInfo.Descripcion },
                    { "@Activo", tipoCostoInfo.Activo },
                    { "@UsuarioCreacionID", tipoCostoInfo.UsuarioCreacionID }
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(parametros);
        }
Esempio n. 18
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(Contexto.Descripcion))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.TipoCostoEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else
                {
                    int    tipoCostoId = Contexto.TipoCostoID;
                    string descripcion = Contexto.Descripcion;

                    var           tipoCostoPL = new TipoCostoPL();
                    TipoCostoInfo tipoCosto   = tipoCostoPL.ObtenerPorDescripcion(descripcion);

                    if (tipoCosto != null && (tipoCostoId == 0 || tipoCostoId != tipoCosto.TipoCostoID))
                    {
                        resultado = false;
                        mensaje   = string.Format(Properties.Resources.TipoCostoEdicion_MsgDescripcionExistente, tipoCosto.TipoCostoID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
Esempio n. 19
0
 /// <summary>
 ///     Metodo que actualiza un Tipo Costo
 /// </summary>
 /// <param name="info"></param>
 internal void Actualizar(TipoCostoInfo info)
 {
     try
     {
         Dictionary <string, object> parameters = AuxTipoCostoDAL.ObtenerParametrosActualizar(info);
         Update("[dbo].[TipoCosto_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);
     }
 }
Esempio n. 20
0
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 internal static TipoCostoInfo ObtenerPorDescripcion(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable     dt      = ds.Tables[ConstantesDAL.DtDatos];
         TipoCostoInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new TipoCostoInfo
         {
             TipoCostoID = info.Field <int>("TipoCostoID"),
             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);
     }
 }
Esempio n. 21
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <TipoCostoInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoCostoInfo filtro)
        {
            ResultadoInfo <TipoCostoInfo> costoLista;

            try
            {
                Logger.Info();
                var tipoCostosDAL = new TipoCostoDAL();
                costoLista = tipoCostosDAL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(costoLista);
        }
Esempio n. 22
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, TipoCostoInfo 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);
        }
Esempio n. 23
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <TipoCostoInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoCostoInfo filtro)
        {
            ResultadoInfo <TipoCostoInfo> costoLista = null;

            try
            {
                Dictionary <string, object> parameters = AuxTipoCostoDAL.ObtenerParametrosPorPagina(pagina, filtro);
                DataSet ds = Retrieve("TipoCosto_ObtenerPorPagina", parameters);
                if (ValidateDataSet(ds))
                {
                    costoLista = MapTipoCostoDAL.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(costoLista);
        }
Esempio n. 24
0
 /// <summary>
 /// Constructor para editar una entidad TipoCosto Existente
 /// </summary>
 /// <param name="tipoCostoInfo"></param>
 public TipoCostoEdicion(TipoCostoInfo tipoCostoInfo)
 {
     InitializeComponent();
     tipoCostoInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
     Contexto = tipoCostoInfo;
 }