/// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 public static ConfiguracionTraspasoAlmacenInfo ObtenerPorID(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
         ConfiguracionTraspasoAlmacenInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new ConfiguracionTraspasoAlmacenInfo
         {
             ConfiguracionTraspasoAlmacenID = info.Field <int>("ConfiguracionTraspasoAlmacenID"),
             TipoAlmacenOrigen = new TipoAlmacenInfo {
                 TipoAlmacenID = info.Field <int>("TipoAlmacenID"), Descripcion = info.Field <string>("TipoAlmacen")
             },
             TipoAlmacenDestino = new TipoAlmacenInfo {
                 TipoAlmacenID = info.Field <int>("TipoAlmacenID"), Descripcion = info.Field <string>("TipoAlmacen")
             },
             DiferenteOrganizacion = info.Field <bool>("DiferenteOrganizacion"),
             Activo = info.Field <bool>("Activo").BoolAEnum(),
         }).First();
         return(entidad);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #2
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad ConfiguracionTraspasoAlmacen
 /// </summary>
 /// <param name="info"></param>
 public int Guardar(ConfiguracionTraspasoAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         var configuracionTraspasoAlmacenDAL = new ConfiguracionTraspasoAlmacenDAL();
         int result = info.ConfiguracionTraspasoAlmacenID;
         if (info.ConfiguracionTraspasoAlmacenID == 0)
         {
             result = configuracionTraspasoAlmacenDAL.Crear(info);
         }
         else
         {
             configuracionTraspasoAlmacenDAL.Actualizar(info);
         }
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #3
0
 /// <summary>
 /// Metodo para Crear un registro de ConfiguracionTraspasoAlmacen
 /// </summary>
 /// <param name="info">Valores de la entidad que será creada</param>
 public int Crear(ConfiguracionTraspasoAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxConfiguracionTraspasoAlmacenDAL.ObtenerParametrosCrear(info);
         int result = Create("ConfiguracionTraspasoAlmacen_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);
     }
 }
Пример #4
0
 /// <summary>
 /// Obtiene un registro de ConfiguracionTraspasoAlmacen
 /// </summary>
 /// <param name="descripcion">Descripción de la ConfiguracionTraspasoAlmacen</param>
 /// <returns></returns>
 public ConfiguracionTraspasoAlmacenInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxConfiguracionTraspasoAlmacenDAL.ObtenerParametrosPorDescripcion(descripcion);
         DataSet ds = Retrieve("ConfiguracionTraspasoAlmacen_ObtenerPorDescripcion", parameters);
         ConfiguracionTraspasoAlmacenInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapConfiguracionTraspasoAlmacenDAL.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);
     }
 }
Пример #5
0
 /// <summary>
 /// Obtiene una entidad ConfiguracionTraspasoAlmacen por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 public ConfiguracionTraspasoAlmacenInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var configuracionTraspasoAlmacenDAL     = new ConfiguracionTraspasoAlmacenDAL();
         ConfiguracionTraspasoAlmacenInfo result = configuracionTraspasoAlmacenDAL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Obtiene parametros para crear
 /// </summary>
 /// <param name="info">Valores de la entidad</param>
 /// <returns></returns>
 public static Dictionary <string, object> ObtenerParametrosCrear(ConfiguracionTraspasoAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@TipoAlmacenOrigenID", info.TipoAlmacenOrigen.TipoAlmacenID },
             { "@TipoAlmacenDestinoID", info.TipoAlmacenDestino.TipoAlmacenID },
             { "@DiferenteOrganizacion", info.DiferenteOrganizacion },
             { "@Activo", info.Activo },
             { "@UsuarioCreacionID", info.UsuarioCreacionID },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #7
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <ConfiguracionTraspasoAlmacenInfo> ObtenerPorPagina(PaginacionInfo pagina, ConfiguracionTraspasoAlmacenInfo filtro)
 {
     try
     {
         Logger.Info();
         var configuracionTraspasoAlmacenDAL = new ConfiguracionTraspasoAlmacenDAL();
         ResultadoInfo <ConfiguracionTraspasoAlmacenInfo> result = configuracionTraspasoAlmacenDAL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #8
0
        /// <summary>
        /// Asigna los eventos a los controles de ayuda
        /// </summary>
        private void AsignarEventosAyudas()
        {
            skAyudaLoteMPOrigen.AyudaConDatos += (sender, args) =>
            {
                Contexto.AlmacenInventarioOrigen.Almacen =
                    Contexto.AlmacenOrigen;
                Contexto.LoteMpOrigen.AlmacenInventario.Almacen =
                    Contexto.AlmacenOrigen;
            };

            skAyudaLoteMPDestino.AyudaConDatos += (sender, args) =>
            {
                Contexto.AlmacenInventarioDestino.Almacen =
                    Contexto.AlmacenDestino;
                Contexto.LoteMpDestino.AlmacenInventario.Almacen = Contexto.AlmacenDestino;
            };

            #region AyudasOrigen

            skAyudaTipoAlmacenOrigen.AyudaConDatos += (o, args) =>
            {
                iudFolio.IsEnabled = false;
                btnBuscarFolioEmbarque.IsEnabled            = false;
                Contexto.AlmacenOrigen.TipoAlmacen          = Contexto.TipoAlmacenOrigen;
                Contexto.AlmacenOrigen.TipoAlmacenID        = Contexto.TipoAlmacenOrigen.TipoAlmacenID;
                Contexto.TipoAlmacenOrigen.ListaTipoAlmacen =
                    configuracionTraspasoAlmacen.Select(tipo => tipo.TipoAlmacenOrigen.TipoAlmacenID).Distinct().
                    ToList();
                var tiposDestino =
                    configuracionTraspasoAlmacen.Where(
                        tipo => tipo.TipoAlmacenOrigen.TipoAlmacenID == Contexto.TipoAlmacenOrigen.TipoAlmacenID);
                if (tiposDestino.Any())
                {
                    Contexto.TipoAlmacenDestino.ListaTipoAlmacen = tiposDestino.Select(tipo => tipo.TipoAlmacenDestino.TipoAlmacenID).Distinct().
                                                                   ToList();
                }
                Contexto.AlmacenOrigen.ListaTipoAlmacen = new List <TipoAlmacenInfo>
                {
                    new TipoAlmacenInfo
                    {
                        TipoAlmacenID = Contexto.TipoAlmacenOrigen.TipoAlmacenID
                    }
                };
            };

            skAyudaOrganizacionOrigen.AyudaConDatos += (o, args) =>
            {
                Contexto.AlmacenOrigen.Organizacion          = Contexto.OrganizacionOrigen;
                Contexto.OrganizacionOrigen.TipoOrganizacion = new TipoOrganizacionInfo
                {
                    TipoOrganizacionID = TipoOrganizacion.Ganadera.GetHashCode()
                };
            };

            skAyudaAlmacenOrigen.AyudaConDatos += (o, args) =>
            {
                Contexto.ProductoOrigen.AlmacenID    = Contexto.AlmacenOrigen.AlmacenID;
                Contexto.AlmacenOrigen.TipoAlmacenID = Contexto.TipoAlmacenOrigen.TipoAlmacenID;
                Contexto.ProveedorOrigen.AlmacenID   = Contexto.AlmacenOrigen.AlmacenID;

                if (Contexto.LoteMpOrigen == null)
                {
                    Contexto.LoteMpOrigen = new AlmacenInventarioLoteInfo
                    {
                        AlmacenInventario = new AlmacenInventarioInfo()
                        {
                            Almacen = Contexto.AlmacenOrigen
                        }
                    };
                }
                else
                {
                    if (Contexto.LoteMpOrigen.AlmacenInventario == null)
                    {
                        Contexto.LoteMpOrigen.AlmacenInventario = new AlmacenInventarioInfo
                        {
                            Almacen = Contexto.AlmacenOrigen
                        };
                    }
                    else
                    {
                        Contexto.LoteMpOrigen.AlmacenInventario.Almacen = Contexto.AlmacenOrigen;
                    }
                }
            };

            skAyudaAlmacenOrigen.PuedeBuscar = () =>
            {
                if ((Contexto.TipoAlmacenOrigen == null || Contexto.TipoAlmacenOrigen.TipoAlmacenID == 0) || (Contexto.OrganizacionOrigen == null || Contexto.OrganizacionOrigen.OrganizacionID == 0))
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.TraspasoMPPAMED_SeleccionarTipoOrganizacion, MessageBoxButton.OK, MessageImage.Warning);
                    return(false);
                }
                return(true);
            };

            skAyudaProductoOrigen.PuedeBuscar = () =>
            {
                if (Contexto.AlmacenOrigen == null || Contexto.AlmacenOrigen.AlmacenID == 0)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.TraspasoMPPAMED_SeleccionarAlmacen, MessageBoxButton.OK, MessageImage.Warning);
                    return(false);
                }
                return(true);
            };

            skAyudaProductoOrigen.AyudaConDatos += (o, args) =>
            {
                Contexto.ProductoOrigen.AlmacenID = Contexto.AlmacenOrigen.AlmacenID;
                BloqueaDesbloqueaControlesDestino(true);
                Contexto.ProductoDestino                = Contexto.ProductoOrigen;
                skAyudaProductoDestino.IsEnabled        = false;
                Contexto.ProveedorOrigen.ProductoID     = Contexto.ProductoOrigen.ProductoId;
                Contexto.ProveedorOrigen.OrganizacionID = Contexto.OrganizacionOrigen.OrganizacionID;

                Contexto.ProveedorDestino.ProductoID     = Contexto.ProductoOrigen.ProductoId;
                Contexto.ProveedorDestino.OrganizacionID = Contexto.OrganizacionOrigen.OrganizacionID;


                Contexto.LoteMpOrigen.OrganizacionId = Contexto.OrganizacionOrigen.OrganizacionID;
                Contexto.LoteMpOrigen.TipoAlmacenId  = Contexto.TipoAlmacenOrigen.TipoAlmacenID;
                Contexto.LoteMpOrigen.ProductoId     = Contexto.ProductoOrigen.ProductoId;
                Contexto.LoteMpOrigen.Activo         = EstatusEnum.Activo;

                if (tiposAlmacenMedicamentos.Contains(Contexto.TipoAlmacenOrigen.TipoAlmacenID))
                {
                    var almacenInventarioPL = new AlmacenInventarioPL();
                    List <AlmacenInventarioInfo> inventarios =
                        almacenInventarioPL.ObtienePorAlmacenIdLlenaProductoInfo(Contexto.AlmacenOrigen);

                    Contexto.AlmacenInventarioOrigen =
                        inventarios.FirstOrDefault(
                            inven => inven.Producto.ProductoId == Contexto.ProductoOrigen.ProductoId);
                }
            };


            #endregion Ayudas Origen

            #region AyudasDestino

            skAyudaTipoAlmacenDestino.PuedeBuscar += () =>
            {
                if ((Contexto.TipoAlmacenOrigen == null || Contexto.TipoAlmacenOrigen.TipoAlmacenID == 0) || (Contexto.OrganizacionOrigen == null || Contexto.OrganizacionOrigen.OrganizacionID == 0))
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.TraspasoMPPAMED_SeleccionarTipoOrganizacion, MessageBoxButton.OK, MessageImage.Warning);
                    return(false);
                }
                return(true);
            };

            skAyudaTipoAlmacenDestino.AyudaConDatos += (o, args) =>
            {
                Contexto.AlmacenDestino.TipoAlmacenID = Contexto.TipoAlmacenDestino.TipoAlmacenID;

                ConfiguracionTraspasoAlmacenInfo configuracionAlmacen =
                    configuracionTraspasoAlmacen.FirstOrDefault(
                        config =>
                        config.TipoAlmacenOrigen.TipoAlmacenID == Contexto.TipoAlmacenOrigen.TipoAlmacenID &&
                        config.TipoAlmacenDestino.TipoAlmacenID == Contexto.TipoAlmacenDestino.TipoAlmacenID);
                if (configuracionAlmacen != null)
                {
                    if (!configuracionAlmacen.DiferenteOrganizacion)
                    {
                        Contexto.OrganizacionDestino         = Contexto.OrganizacionOrigen;
                        skAyudaOrganizacionDestino.IsEnabled = false;
                    }
                }
                Contexto.AlmacenDestino.Organizacion = Contexto.OrganizacionDestino;
                MostrarControlesCantidades();

                var tiposDestino =
                    configuracionTraspasoAlmacen.Where(
                        tipo => tipo.TipoAlmacenOrigen.TipoAlmacenID == Contexto.TipoAlmacenOrigen.TipoAlmacenID);
                if (tiposDestino.Any())
                {
                    Contexto.TipoAlmacenDestino.ListaTipoAlmacen = tiposDestino.Select(tipo => tipo.TipoAlmacenDestino.TipoAlmacenID).Distinct().
                                                                   ToList();
                    Contexto.AlmacenDestino.ListaTipoAlmacen = tiposDestino.Select(tipo => tipo.TipoAlmacenDestino).Distinct().
                                                               ToList();
                }
            };

            skAyudaOrganizacionDestino.AyudaConDatos += (o, args) =>
            {
                Contexto.AlmacenDestino.Organizacion = Contexto.OrganizacionDestino;
            };

            skAyudaAlmacenDestino.AyudaConDatos += (o, args) =>
            {
                Contexto.ProductoDestino.AlmacenID    = Contexto.AlmacenDestino.AlmacenID;
                Contexto.AlmacenDestino.TipoAlmacenID = Contexto.TipoAlmacenDestino.TipoAlmacenID;
                Contexto.ProveedorDestino.AlmacenID   = Contexto.AlmacenDestino.AlmacenID;

                Contexto.LoteMpDestino.OrganizacionId = Contexto.OrganizacionDestino.OrganizacionID;
                Contexto.LoteMpDestino.TipoAlmacenId  = Contexto.TipoAlmacenDestino.TipoAlmacenID;
                Contexto.LoteMpDestino.ProductoId     = Contexto.ProductoDestino.ProductoId;
                Contexto.LoteMpDestino.Activo         = EstatusEnum.Activo;

                var tiposDestino =
                    configuracionTraspasoAlmacen.Where(
                        tipo => tipo.TipoAlmacenOrigen.TipoAlmacenID == Contexto.TipoAlmacenOrigen.TipoAlmacenID);
                Contexto.TipoAlmacenDestino.ListaTipoAlmacen = tiposDestino.Select(tipo => tipo.TipoAlmacenDestino.TipoAlmacenID).Distinct().
                                                               ToList();
                Contexto.AlmacenDestino.ListaTipoAlmacen = tiposDestino.Select(tipo => tipo.TipoAlmacenDestino).Distinct().
                                                           ToList();

                if (Contexto.LoteMpDestino == null)
                {
                    Contexto.LoteMpDestino = new AlmacenInventarioLoteInfo
                    {
                        AlmacenInventario = new AlmacenInventarioInfo()
                        {
                            Almacen = Contexto.AlmacenDestino
                        }
                    };
                }
                else
                {
                    if (Contexto.LoteMpDestino.AlmacenInventario == null)
                    {
                        Contexto.LoteMpDestino.AlmacenInventario = new AlmacenInventarioInfo
                        {
                            Almacen = Contexto.AlmacenDestino
                        };
                    }
                    else
                    {
                        Contexto.LoteMpDestino.AlmacenInventario.Almacen = Contexto.AlmacenDestino;
                    }
                }
            };


            skAyudaCuentaContableContratoDestino.AyudaConDatos += (sender, args) => CargarCuentasContables();

            #endregion AyudasDestino
        }
 /// <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, ConfiguracionTraspasoAlmacenInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ConfiguracionTraspasoAlmacenID", filtro.ConfiguracionTraspasoAlmacenID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #10
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <ConfiguracionTraspasoAlmacenInfo> ObtenerPorPagina(PaginacionInfo pagina, ConfiguracionTraspasoAlmacenInfo filtro)
 {
     try
     {
         Dictionary <string, object> parameters = AuxConfiguracionTraspasoAlmacenDAL.ObtenerParametrosPorPagina(pagina, filtro);
         DataSet ds = Retrieve("ConfiguracionTraspasoAlmacen_ObtenerPorPagina", parameters);
         ResultadoInfo <ConfiguracionTraspasoAlmacenInfo> result = null;
         if (ValidateDataSet(ds))
         {
             result = MapConfiguracionTraspasoAlmacenDAL.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);
     }
 }