Example #1
0
 /// <summary>
 /// Metodo para Crear un registro de ProveedorAlmacen
 /// </summary>
 /// <param name="info">Valores de la entidad que será creada</param>
 public int Crear(ProveedorAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxProveedorAlmacenDAL.ObtenerParametrosCrear(info);
         int result = Create("ProveedorAlmacen_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);
     }
 }
        /// <summary>
        /// Obtiene un proveedor almacen por proveedorid
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        internal static ProveedorAlmacenInfo ObtenerPorProveedorTipoAlmacen(DataSet ds)
        {
            try
            {
                Logger.Info();
                DataTable dt = ds.Tables[ConstantesDAL.DtDatos];

                ProveedorAlmacenInfo entidad =
                    (from info in dt.AsEnumerable()
                     select
                     new ProveedorAlmacenInfo
                {
                    ProveedorAlmacenId = info.Field <int>("ProveedorAlmacenID"),
                    ProveedorId = info.Field <int>("ProveedorID"),
                    Proveedor = new ProveedorInfo
                    {
                        ProveedorID = info.Field <int>("ProveedorID")
                    },
                    AlmacenId = info.Field <int>("AlmacenID"),
                    Activo = info.Field <bool>("Activo").BoolAEnum(),
                    FechaCreacion = info.Field <DateTime>("FechaCreacion"),
                    UsuarioCreacionID = info.Field <int>("UsuarioCreacionID")
                }).First();
                return(entidad);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Example #3
0
 /// <summary>
 /// Metodo que obtiene un proveedor almacen por proveedor id
 /// </summary>
 /// <returns></returns>
 internal ProveedorAlmacenInfo ObtenerPorAlmacenID(int almacenID)
 {
     try
     {
         Logger.Info();
         var parameters = AuxProveedorAlmacenDAL.ObtenerParametrosObtenerPorAlmacenID(almacenID);
         var ds         = Retrieve("ProveedorAlmacen_ObtenerPorAlmacenID", parameters);
         ProveedorAlmacenInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapProveedorAlmacenDAL.ObtenerPorAlmacenID(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);
     }
 }
Example #4
0
        /// <summary>
        /// Obtiene un proveedor por id y tipo de almacen
        /// </summary>
        /// <param name="proveedorInfo"></param>
        /// <returns></returns>
        public ProveedorAlmacenInfo ObtenerPorProveedorTipoAlmacen(ProveedorAlmacenInfo proveedorInfo)
        {
            ProveedorAlmacenInfo proveedorAlmacen;

            try
            {
                Logger.Info();
                var proveedorAlmacenBl = new ProveedorAlmacenBL();
                proveedorAlmacen = proveedorAlmacenBl.ObtenerPorProveedorTipoAlmacen(proveedorInfo);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(proveedorAlmacen);
        }
 /// <summary>
 /// Obtiene parametros para crear
 /// </summary>
 /// <param name="info">Valores de la entidad</param>
 /// <returns></returns>
 public static Dictionary <string, object> ObtenerParametrosCrear(ProveedorAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ProveedorID", info.Proveedor.ProveedorID },
             { "@AlmacenID", info.Almacen.AlmacenID },
             { "@Activo", info.Activo },
             { "@UsuarioCreacionID", info.UsuarioCreacionID },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #6
0
 /// <summary>
 /// Metodo para actualizar un registro de ProveedorAlmacen
 /// </summary>
 /// <param name="info">Valores de la entidad que se actualizarán</param>
 public void Actualizar(ProveedorAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxProveedorAlmacenDAL.ObtenerParametrosActualizar(info);
         Update("ProveedorAlmacen_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);
     }
 }
Example #7
0
        /// <summary>
        /// Metodo para Guardar/Modificar una entidad Almacen
        /// </summary>
        /// <param name="info"></param>
        internal int Guardar(AlmacenInfo info)
        {
            try
            {
                Logger.Info();
                var  almacenDAL     = new AlmacenDAL();
                int  result         = info.AlmacenID;
                bool esModificacion = result > 0;
                using (var scope = new TransactionScope())
                {
                    if (info.AlmacenID == 0)
                    {
                        result = almacenDAL.Crear(info);
                    }
                    else
                    {
                        almacenDAL.Actualizar(info);
                    }
                    if (info.Proveedor != null && info.Proveedor.ProveedorID > 0)
                    {
                        var proveedorAlmacenDAL = new ProveedorAlmacenDAL();
                        var proveedorAlmacen    = new ProveedorAlmacenInfo
                        {
                            Proveedor = info.Proveedor,
                            Almacen   = new AlmacenInfo
                            {
                                AlmacenID = result
                            }
                        };
                        if (esModificacion)
                        {
                            ProveedorAlmacenInfo proveedorAlmacenExiste =
                                proveedorAlmacenDAL.ObtenerPorAlmacenID(result);
                            if (info.Activo == EstatusEnum.Inactivo)
                            {
                                if (proveedorAlmacenExiste != null)
                                {
                                    proveedorAlmacenExiste.Activo = EstatusEnum.Inactivo;
                                    proveedorAlmacenExiste.UsuarioModificacionID = info.UsuarioModificacionID;
                                    proveedorAlmacenDAL.Actualizar(proveedorAlmacenExiste);
                                    scope.Complete();
                                    return(result);
                                }
                            }

                            if (proveedorAlmacenExiste != null)
                            {
                                proveedorAlmacenExiste.UsuarioModificacionID = info.UsuarioModificacionID.HasValue ? info.UsuarioModificacionID.Value : 0;
                                proveedorAlmacenExiste.Proveedor             = info.Proveedor;
                                proveedorAlmacenDAL.Actualizar(proveedorAlmacenExiste);
                                scope.Complete();
                                return(result);
                            }
                        }
                        else
                        {
                            proveedorAlmacen.UsuarioCreacionID = info.UsuarioCreacionID;
                        }
                        proveedorAlmacenDAL.Crear(proveedorAlmacen);
                    }
                    scope.Complete();
                }
                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// Metodo que valida los datos para guardar
        /// </summary>
        /// <returns></returns>
        private bool ValidaGuardar()
        {
            bool   resultado = true;
            string mensaje   = string.Empty;

            try
            {
                if (string.IsNullOrWhiteSpace(txtAlmacenID.Text))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgAlmacenIDRequerida;
                    txtAlmacenID.Focus();
                }
                else if (string.IsNullOrWhiteSpace(Contexto.Descripcion))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else if (string.IsNullOrWhiteSpace(Contexto.CodigoAlmacen))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgCodigoAlmacenRequerida;
                    txtCodigoAlmacen.Focus();
                }
                else if (Contexto.Organizacion == null || Contexto.Organizacion.OrganizacionID == 0)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgOrganizacionIDRequerida;
                    skAyudaOrganizacion.AsignarFoco();
                }

                else if (Contexto.TipoAlmacen.TipoAlmacenID == 0)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgTipoAlmacenIDRequerida;
                    cmbTipoAlmacen.Focus();
                }
                else if (validaProveedor && (Contexto.Proveedor == null || Contexto.Proveedor.ProveedorID == 0))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgProveedorRequerido;
                    skAyudaProveedor.AsignarFoco();
                }
                else if (cmbActivo.SelectedItem == null)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.AlmacenEdicion_MsgActivoRequerida;
                    cmbActivo.Focus();
                }
                else if (validaProveedor)
                {
                    if (Contexto.AlmacenID == 0 && Contexto.Proveedor != null && Contexto.Proveedor.ProveedorID > 0)
                    {
                        var proveedorAlmacenPL   = new ProveedorAlmacenPL();
                        var proveedorAlmacenInfo = new ProveedorAlmacenInfo
                        {
                            Proveedor = Contexto.Proveedor,
                            Almacen   = new AlmacenInfo
                            {
                                TipoAlmacenID = Contexto.TipoAlmacen.TipoAlmacenID
                            },
                            Activo = EstatusEnum.Activo
                        };
                        ProveedorAlmacenInfo proveedorAlmacen =
                            proveedorAlmacenPL.ObtenerPorProveedorTipoAlmacen(proveedorAlmacenInfo);
                        if (proveedorAlmacen != null)
                        {
                            resultado = false;
                            mensaje   = Properties.Resources.AlmacenEdicion_MsgProveedorAlmacenExistente;
                            skAyudaProveedor.AsignarFoco();
                        }
                    }
                }
                else
                {
                    int    almacenId   = Extensor.ValorEntero(txtAlmacenID.Text);
                    string descripcion = txtDescripcion.Text;

                    var         almacenPL = new AlmacenPL();
                    AlmacenInfo almacen   = almacenPL.ObtenerPorDescripcion(descripcion);

                    if (almacen == null)
                    {
                        return(true);
                    }

                    if (almacen.TipoAlmacen.TipoAlmacenID != Contexto.TipoAlmacen.TipoAlmacenID && almacen.Organizacion.OrganizacionID == Contexto.Organizacion.OrganizacionID)
                    {
                        bool tieneProductos = almacenPL.ValidarProductosEnAlmacen(almacen);
                        if (tieneProductos)
                        {
                            mensaje   = Properties.Resources.AlmacenEdicion_MsgTipoAlmacenCambio;
                            resultado = false;
                        }
                    }

                    if ((almacenId == 0 || almacenId != almacen.AlmacenID) && almacen.Organizacion.OrganizacionID == Contexto.Organizacion.OrganizacionID)
                    {
                        resultado = false;
                        mensaje   = string.Format(
                            Properties.Resources.AlmacenEdicion_MsgDescripcionExistente, almacen.AlmacenID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
Example #9
0
        private IList <PolizaInfo> ObtenerPoliza(PolizaContratoModel datosContrato)
        {
            var polizasContrato = new List <PolizaInfo>();

            int      folioPedido    = datosContrato.Contrato.Folio;
            int      organizacionID = datosContrato.Contrato.Organizacion.OrganizacionID;
            DateTime fechaPedido    = datosContrato.Contrato.Fecha;

            int    miliSegunda  = DateTime.Now.Millisecond;
            string archivoFolio = ObtenerArchivoFolio(fechaPedido);

            OrganizacionInfo organizacion = ObtenerOrganizacionIVA(organizacionID);

            var tipoContrato   = (TipoContratoEnum)datosContrato.Contrato.TipoContrato.TipoContratoId;
            var tipoPolizaEnum = TipoPoliza.PolizaContratoTerceros;

            switch (tipoContrato)
            {
            case TipoContratoEnum.EnTransito:
                tipoPolizaEnum = TipoPoliza.PolizaContratoTransito;
                break;
            }
            TipoPolizaInfo tipoPoliza =
                TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == tipoPolizaEnum.GetHashCode());

            if (tipoPoliza == null)
            {
                throw new ExcepcionServicio(string.Format("{0} {1}", "EL TIPO DE POLIZA",
                                                          TipoPoliza.PolizaContratoTerceros));
            }

            string textoDocumento = tipoPoliza.TextoDocumento;
            string tipoMovimiento = tipoPoliza.ClavePoliza;
            string postFijoRef3   = tipoPoliza.PostFijoRef3;

            var ref3 = new StringBuilder();

            ref3.Append("03");
            ref3.Append(Convert.ToString(folioPedido).PadLeft(10, ' '));
            ref3.Append(new Random(10).Next(10, 20));
            ref3.Append(new Random(30).Next(30, 40));
            ref3.Append(miliSegunda);
            ref3.Append(postFijoRef3);

            //string numeroDocumento = ObtenerNumeroReferencia;
            string numeroDocumento = ObtenerNumeroReferenciaFolio(datosContrato.AlmacenMovimiento.FolioMovimiento);

            var proveedorAlmacenBL = new ProveedorAlmacenBL();
            ProveedorAlmacenInfo proveedorAlmacen =
                proveedorAlmacenBL.ObtenerPorProveedorId(datosContrato.Contrato.Proveedor);

            if (proveedorAlmacen == null)
            {
                throw new ExcepcionServicio(string.Format("EL PROVEEDOR {0} NO TIENE ALMACEN ASIGNADO",
                                                          datosContrato.Contrato.Proveedor.Descripcion));
            }
            decimal importe = datosContrato.Contrato.Precio * datosContrato.Contrato.Cantidad;
            var     renglon = 1;
            var     datos   = new DatosPolizaInfo
            {
                NumeroReferencia = numeroDocumento,
                FechaEntrada     = datosContrato.Contrato.Fecha,
                Folio            = datosContrato.Contrato.Folio.ToString(),
                Importe          =
                    string.Format("{0}", importe.ToString("F2")),
                Renglon          = Convert.ToString(renglon),
                ImporteIva       = "0",
                Ref3             = ref3.ToString(),
                Cuenta           = datosContrato.Contrato.Cuenta.CuentaSAP,
                ArchivoFolio     = archivoFolio,
                DescripcionCosto = datosContrato.Contrato.Cuenta.Descripcion,
                PesoOrigen       = Math.Round(Convert.ToDecimal(datosContrato.Contrato.Cantidad), 0),
                Division         = organizacion.Division,
                TipoDocumento    = textoDocumento,
                ClaseDocumento   = postFijoRef3,
                Concepto         = String.Format("{0}-{1} {2} {3} {4} ${5} {6}",
                                                 tipoMovimiento,
                                                 datosContrato.Contrato.Folio,
                                                 datosContrato.Contrato.Cantidad.ToString("N0"),
                                                 "KGS", datosContrato.Contrato.Producto.Descripcion,
                                                 importe.ToString("N2"), postFijoRef3),
                Sociedad = organizacion.Sociedad,
                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
            };
            PolizaInfo poliza = GeneraRegistroPoliza(datos);

            polizasContrato.Add(poliza);

            renglon++;
            datos = new DatosPolizaInfo
            {
                NumeroReferencia = numeroDocumento,
                FechaEntrada     = datosContrato.Contrato.Fecha,
                Folio            = datosContrato.Contrato.Folio.ToString(),
                ClaveProveedor   = datosContrato.Contrato.Proveedor.CodigoSAP,
                Importe          =
                    string.Format("{0}", (importe * -1).ToString("F2")),
                Renglon          = Convert.ToString(renglon),
                Division         = organizacion.Division,
                ImporteIva       = "0",
                Ref3             = ref3.ToString(),
                ArchivoFolio     = archivoFolio,
                DescripcionCosto = datosContrato.Contrato.Proveedor.Descripcion,
                PesoOrigen       = Math.Round(Convert.ToDecimal(datosContrato.Contrato.Cantidad), 0),
                TipoDocumento    = textoDocumento,
                ClaseDocumento   = postFijoRef3,
                Concepto         = String.Format("{0}-{1} {2} {3} {4} ${5} {6}",
                                                 tipoMovimiento,
                                                 datosContrato.Contrato.Folio,
                                                 datosContrato.Contrato.Cantidad.ToString("N0"),
                                                 "KGS", datosContrato.Contrato.Producto.Descripcion,
                                                 importe.ToString("N2"), postFijoRef3),
                Sociedad = organizacion.Sociedad,
                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
            };
            poliza = GeneraRegistroPoliza(datos);
            polizasContrato.Add(poliza);

            return(polizasContrato);
        }
        private void ObtenerDatosProveedorAlmacen(string filtro)
        {
            try
            {
                if (string.IsNullOrEmpty(filtro))
                {
                    skAyudaProveedores.Info = new ProveedorInfo
                    {
                        ListaTiposProveedor = new List <TipoProveedorInfo>
                        {
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                            },
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                            }
                        },
                        Activo = EstatusEnum.Activo
                    };
                    return;
                }
                if (skAyudaProveedores.Info == null)
                {
                    skAyudaProveedores.Info = new ProveedorInfo
                    {
                        ListaTiposProveedor = new List <TipoProveedorInfo>
                        {
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                            },
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                            }
                        },
                        Activo = EstatusEnum.Activo
                    };
                    return;
                }
                if (skAyudaProveedores.Info.TipoProveedor.TipoProveedorID !=
                    TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode() && skAyudaProveedores.Info.TipoProveedor.TipoProveedorID !=
                    TipoProveedorEnum.ProveedoresFletes.GetHashCode())///Descomentar
                {
                    skAyudaProveedores.Info = new ProveedorInfo
                    {
                        ListaTiposProveedor = new List <TipoProveedorInfo>
                        {
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                            },
                            new TipoProveedorInfo
                            {
                                TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                            }
                        },
                        Activo = EstatusEnum.Activo
                    };

                    skAyudaProveedores.LimpiarCampos();
                    skAyudaProveedores.AsignarFoco();
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.CrearContrato_MensajeProveedorInvalido,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                }
                else
                {
                    var proveedorAlmacen   = new ProveedorAlmacenInfo();
                    var proveedorAlmacenPl = new ProveedorAlmacenPL();
                    var proveedor          = new ProveedorInfo();
                    var proveedorPl        = new ProveedorPL();
                    proveedor = proveedorPl.ObtenerPorCodigoSAP(new ProveedorInfo()
                    {
                        CodigoSAP = filtro
                    });

                    if (proveedor != null)
                    {
                        proveedorAlmacen = proveedorAlmacenPl.ObtenerPorProveedorId(proveedor);
                        if (proveedorAlmacen != null)
                        {
                            skAyudaProveedores.Info = new ProveedorInfo
                            {
                                ListaTiposProveedor = new List <TipoProveedorInfo>
                                {
                                    new TipoProveedorInfo
                                    {
                                        TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                                    },
                                    new TipoProveedorInfo
                                    {
                                        TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                                    }
                                },
                                Activo = EstatusEnum.Activo
                            };
                        }
                        else
                        {
                            skAyudaProveedores.Info = new ProveedorInfo
                            {
                                ListaTiposProveedor = new List <TipoProveedorInfo>
                                {
                                    new TipoProveedorInfo
                                    {
                                        TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                                    },
                                    new TipoProveedorInfo
                                    {
                                        TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                                    }
                                },
                                Activo = EstatusEnum.Activo
                            };
                            skAyudaProveedores.LimpiarCampos();
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                              Properties.Resources.CrearContrato_MensajeProveedorSinAlmacen,
                                              MessageBoxButton.OK,
                                              MessageImage.Stop);
                        }
                    }
                    else
                    {
                        skAyudaProveedores.Info = new ProveedorInfo
                        {
                            ListaTiposProveedor = new List <TipoProveedorInfo>
                            {
                                new TipoProveedorInfo
                                {
                                    TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
                                },
                                new TipoProveedorInfo
                                {
                                    TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
                                }
                            },
                            Activo = EstatusEnum.Activo
                        };
                        skAyudaProveedores.LimpiarCampos();
                        skAyudaProveedores.AsignarFoco();
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                          Properties.Resources.CrearContrato_MensajeProveedorInvalido,
                                          MessageBoxButton.OK,
                                          MessageImage.Stop);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }
        }
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosObtenerPorProveedorTipoAlmacen(ProveedorAlmacenInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ProveedorID", info.Proveedor.ProveedorID },
             { "@TipoAlmacenID", info.Almacen.TipoAlmacenID },
             { "@Activo", info.Activo.GetHashCode() },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }