/// <summary>
        /// Cancela un folio de traspaso
        /// </summary>
        private void CancelarTraspaso()
        {
            try
            {
                string mensajeValidar = ValidaGuardar();

                if (!string.IsNullOrWhiteSpace(mensajeValidar))
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], mensajeValidar, MessageBoxButton.OK, MessageImage.Warning);
                    return;
                }

                var traspasoMateriaPrimaBL = new TraspasoMateriaPrimaBL();
                var usuario = new UsuarioInfo
                {
                    UsuarioID    = AuxConfiguracion.ObtenerUsuarioLogueado(),
                    Organizacion = new OrganizacionInfo
                    {
                        OrganizacionID = AuxConfiguracion.ObtenerOrganizacionUsuario()
                    }
                };
                Contexto.Usuario = usuario;
                var  resultado = traspasoMateriaPrimaBL.CancelarTraspaso(Contexto);
                long folio     = 0;
                if (resultado != null)
                {
                    foreach (var poliza in resultado)
                    {
                        folio = poliza.Key;
                        if (poliza.Value != null)
                        {
                            var exportarPoliza = new ExportarPoliza();
                            exportarPoliza.ImprimirPoliza(poliza.Value,
                                                          string.Format("{0} {1} Folio - {2} Cancelación", "Póliza",
                                                                        TipoPoliza.EntradaTraspaso, folio));
                        }
                    }
                }
                string mensaje = string.Format(Properties.Resources.TraspasoMPPAMED_FolioCancelado, folio);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], mensaje,
                                  MessageBoxButton.OK,
                                  MessageImage.Correct);
                Limpiar();
            }
            catch (ExcepcionServicio ex)
            {
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], ex.Message, MessageBoxButton.OK, MessageImage.Stop);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  Properties.Resources.TraspasoMPPAMED_ErrorCancelar, MessageBoxButton.OK,
                                  MessageImage.Error);
            }
        }
        private void BtnGuardar_OnClick(object sender, RoutedEventArgs e)
        {
            try
            {
                Contexto.Importe = txtImporte.Text == string.Empty ? 0 : int.Parse(txtImporte.Text);
                if (DatosObligatoriosProporcionados())                                        //:si se proporcionaron los datos obligatorios
                {
                    ActualizarDetalles(Contexto, int.Parse(txtTotalCabezas.Text));            //genera los importes para los costos
                    Contexto.Kilos = (int.Parse(txtPesoPromedio.Text) * Contexto.NumCabezas); //calcula los kilos que se daran salida segun la cantidad de cabezas
                    var  salida = new SalidaPorMuerteEnTransitoBl();
                    bool t;
                    Contexto.CorralID = (int)cbCorrales.SelectedValue;
                    MemoryStream ms = salida.GuardarSalida(Contexto, out t);//memoryStream con la informacion que se guardara en el archivo PDF
                    if (t)
                    {
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                          String.Format(Properties.Resources.SalidaGanadoTransito_MsgRegistroExito, Contexto.Folio), MessageBoxButton.OK, MessageImage.Correct);

                        var    poliza = new ExportarPoliza();
                        string pdfFile;
                        pdfFile = string.Format("{0} {1}", Contexto.Muerte ? "Poliza de Salida Ganado Transito por Muerte Folio " : "Poliza de Salida Ganado Transito por Venta Folio ", Contexto.Folio);
                        poliza.ImprimirPoliza(ms, pdfFile);//genera el archivo PDF con el nombre especificado

                        InicializaContexto();
                        CargarCorralesComboBox();

                        dtpFecha.Text = string.Empty;
                        txtLote.Clear();
                        txtTotalCabezas.Clear();
                        txtPesoPromedio.Clear();
                        cbCorrales.SelectedIndex = 0;
                    }
                    else
                    {
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.SalidaGanadoTransito_MsgErrorRegistrar
                                          , MessageBoxButton.OK, MessageImage.Error);
                        InicializaContexto();
                        CargarCorralesComboBox();
                        dtpFecha.Text = string.Empty;
                        txtLote.Clear();
                        txtTotalCabezas.Clear();
                        txtPesoPromedio.Clear();
                        cbCorrales.SelectedIndex = 0;
                    }
                }
            }
            catch (Exception ex)
            {
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  ex.Message, MessageBoxButton.OK, MessageImage.Error);
            }
        }
示例#3
0
 private void ImprimePoliza(IList <ResultadoPolizaModel> pdf, TipoPoliza tipoPoliza)
 {
     if (tipoPoliza == TipoPoliza.PaseProceso)
     {
         ExportarPolizaPaseProceso(pdf);
     }
     else
     {
         var exportarPoliza = new ExportarPoliza();
         for (var indexPolizas = 0; indexPolizas < pdf.Count; indexPolizas++)
         {
             exportarPoliza.ImprimirPoliza(pdf[indexPolizas].PDF, string.Format("{0} {1}", "Poliza", tipoPoliza));
         }
     }
 }
示例#4
0
        /// <summary>
        /// Metodo para cancelar un Entrada Ganado Costeo
        /// </summary>
        private void CancelarEntradaGanadoCosteo()
        {
            ContenedorCosteoEntrada.EntradaGanadoCosteo.Activo = EstatusEnum.Inactivo;
            ContenedorCosteoEntrada.EntradaGanadoCosteo.UsuarioModificacionID = usuarioLogueadoID;
            ContenedorCosteoEntrada.EntradaGanadoCosteo.ListaEntradaDetalle.ForEach(det =>
            {
                det.Activo = EstatusEnum.Inactivo;
                det.UsuarioModificacionID = usuarioLogueadoID;
            });
            ContenedorCosteoEntrada.EntradaGanadoCosteo.ListaCostoEntrada.ForEach(cost =>
            {
                cost.Activo = EstatusEnum.Inactivo;
                cost.UsuarioModificacionID = usuarioLogueadoID;
            });
            ContenedorCosteoEntrada.EntradaGanadoCosteo.ListaCalidadGanado.ForEach(cali =>
            {
                if (cali.EntradaGanadoCalidadID != 0)
                {
                    cali.Activo = EstatusEnum.Inactivo;
                    cali.UsuarioModificacionID = usuarioLogueadoID;
                }
            });

            ContenedorCosteoEntrada.EntradaGanado.UsuarioModificacionID = usuarioLogueadoID;
            ContenedorCosteoEntrada.EntradaGanado.Costeado = false;

            ObtenerDatosEntradaGanadoTransito();
            ObtenerDatosEntradaGanadoMuerte();

            var          entradaGanadoCosteoPL = new EntradaGanadoCosteoPL();
            MemoryStream stream = entradaGanadoCosteoPL.Guardar(ContenedorCosteoEntrada);

            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                              Properties.Resources.CosteoEntradaGanado_CanceladoExitoso, MessageBoxButton.OK,
                              MessageImage.Correct);
            if (stream != null)
            {
                var exportarPoliza = new ExportarPoliza();
                exportarPoliza.ImprimirPoliza(stream,
                                              string.Format("{0} {1}", "Cancelacion de Poliza de Entrada Folio ",
                                                            ContenedorCosteoEntrada.EntradaGanado.FolioEntrada));
            }
            LimpiarControles();
        }
        /// <summary>
        /// Boton guardar
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnGuardar_OnClick(object sender, RoutedEventArgs e)
        {
            if (ValidarGuardar())
            {
                var ganadoIntensivo = new GanadoIntensivoPL();
                var resultado       = ganadoIntensivo.MuerteGanadoIntensivo_Guardar(Contexto);

                if (resultado.stream != null)
                {
                    var exportarPoliza = new ExportarPoliza();
                    exportarPoliza.ImprimirPoliza(resultado.stream,
                                                  string.Format("{0} {1}", "Poliza Salida Muerte Ganado Intensivo Folio No.",
                                                                resultado.FolioTicket));
                }

                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], String.Format(Properties.Resources.MuerteGanadoIntensivo_msgGuardadoConExito, resultado.FolioTicket),// folio.ToString(CultureInfo.InvariantCulture)),
                                  MessageBoxButton.OK, MessageImage.Correct);
                InicializaContexto();
            }
        }
        /// <summary>
        /// Método para cancelar
        /// </summary>
        private void Guardar()
        {
            bool guardar = ValidaGuardar();

            if (guardar)
            {
                try
                {
                    SolicitudProductoReplicaInfo solicitudGuardar = Contexto;
                    var organizacion = new OrganizacionPL().ObtenerPorID(solicitudGuardar.AlmacenDestino.Organizacion.OrganizacionID);
                    var tipoOrg      = organizacion.TipoOrganizacion.TipoOrganizacionID;

                    solicitudGuardar.UsuarioModificacionID = usuario.UsuarioID;
                    int activos   = solicitudGuardar.Detalle.Count(e => e.Activo == true);
                    int recibidos =
                        solicitudGuardar.Detalle.Count(
                            e => e.Activo == true);
                    if (tipoOrg == TipoOrganizacion.Centro.GetHashCode() || tipoOrg == TipoOrganizacion.Cadis.GetHashCode() || tipoOrg == TipoOrganizacion.Descanso.GetHashCode())
                    {
                        var misAretes = ObtenerTotalAretesGrid();
                        var result    = new SolicitudProductoBL().GuardarInformacionCentros(Contexto.FolioSolicitud.ToString(), AuxConfiguracion.ObtenerUsuarioLogueado(), solicitudGuardar.AlmacenDestino.Organizacion.OrganizacionID, misAretes);
                        if (result)
                        {
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.RecibirProductoAlmacen_GuardadoConExito,
                                              MessageBoxButton.OK,
                                              MessageImage.Correct);
                            Limpiar();
                        }
                        else
                        {
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.RecibirProductoAlmacen_ErrorGuardar,
                                              MessageBoxButton.OK,
                                              MessageImage.Error);
                        }
                    }
                    else
                    {
                        MemoryStream pdf = solicitudProductoBL.GuardarMovimientoInventario(solicitudGuardar);
                        if (pdf != null)
                        {
                            var exportarPoliza = new ExportarPoliza();
                            if (solicitudGuardar.AlmacenID.HasValue)
                            {
                                exportarPoliza.ImprimirPoliza(pdf, string.Format("{0} {1}", "Poliza", TipoPoliza.EntradaTraspasoSAP));
                            }
                            else
                            {
                                exportarPoliza.ImprimirPoliza(pdf,
                                                              string.Format("{0} {1}", "Poliza", TipoPoliza.SalidaConsumo));
                            }
                        }

                        string mensaje = Properties.Resources.RecibirProductoAlmacen_GuardadoConExito;
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], mensaje,
                                          MessageBoxButton.OK,
                                          MessageImage.Correct);
                        Limpiar();
                    }
                }
                catch (ExcepcionServicio ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecibirProductoAlmacen_ErrorGuardar, MessageBoxButton.OK,
                                      MessageImage.Stop);
                }
                catch (ExcepcionGenerica ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecibirProductoAlmacen_ErrorGuardar, MessageBoxButton.OK,
                                      MessageImage.Error);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecibirProductoAlmacen_ErrorGuardar, MessageBoxButton.OK,
                                      MessageImage.Error);
                }
            }
        }
        private void ImprimePoliza(MemoryStream pdf, TipoPoliza tipoPoliza)
        {
            var exportarPoliza = new ExportarPoliza();

            exportarPoliza.ImprimirPoliza(pdf, string.Format("{0} {1}", "Poliza", tipoPoliza));
        }
        private void BtnGuardar_OnClick(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(txtOrdenCompra.Text))
                {
                    if (recepcionProducto.ListaRecepcionProductoDetalle != null)
                    {
                        if (recepcionProducto.ListaRecepcionProductoDetalle.Count > 0)
                        {
                            var recepcionProductoPl = new RecepcionProductoPL();
                            recepcionProducto.Almacen = new AlmacenInfo()
                            {
                                AlmacenID    = int.Parse(txtAlmacenGeneral.Text),
                                Organizacion = new OrganizacionInfo()
                                {
                                    OrganizacionID = organizacionId
                                }
                            };
                            recepcionProducto.FolioOrdenCompra = txtOrdenCompra.Text;
                            recepcionProducto.FechaSolicitud   = recepcionProductoCompra.FechaSolicitud;
                            var proveedorPl = new ProveedorPL();
                            recepcionProducto.Proveedor =
                                proveedorPl.ObtenerPorCodigoSAP(new ProveedorInfo()
                            {
                                CodigoSAP = skAyudaProveedor.Clave
                            });
                            recepcionProducto.Factura         = txtFactura.Text;
                            recepcionProducto.UsuarioCreacion = new UsuarioInfo()
                            {
                                UsuarioID = usuarioId
                            };
                            recepcionProducto.Observaciones = txtObservaciones.Text;
                            MemoryStream retorno = recepcionProductoPl.Guardar(recepcionProducto);
                            if (retorno != null)
                            {
                                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                                  Properties.Resources.RecepcionProducto_msgDatosGuardados,
                                                  MessageBoxButton.OK,
                                                  MessageImage.Correct);

                                var exportarPoliza = new ExportarPoliza();
                                exportarPoliza.ImprimirPoliza(retorno,
                                                              string.Format("{0} {1}",
                                                                            "Poliza de Entrada Compra Materia Prima Folio",
                                                                            txtOrdenCompra.Text));
                                LimpiarTodo();
                            }
                            else
                            {
                                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                                  Properties.Resources.RecepcionProducto_msgOcurrioErrorGuardar,
                                                  MessageBoxButton.OK,
                                                  MessageImage.Stop);
                            }
                        }
                        else
                        {
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                              Properties.Resources.RecepcionProducto_msgIngresarProductos,
                                              MessageBoxButton.OK,
                                              MessageImage.Stop);
                        }
                    }
                    else
                    {
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                          Properties.Resources.RecepcionProducto_msgIngresarProductos,
                                          MessageBoxButton.OK,
                                          MessageImage.Stop);
                    }
                }
                else
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecepcionProducto_IngresarFolioOrdenCompra,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    txtOrdenCompra.Focus();
                }
            }
            catch (ExcepcionServicio ex)
            {
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  ex.Message, MessageBoxButton.OK, MessageImage.Stop);
            }
            catch (ExcepcionGenerica ex)
            {
                Logger.Error(ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }
        }
示例#9
0
        private void btnGuardar_Click(object sender, RoutedEventArgs e)
        {
            int           folioTicket, numeroDeCabezas;
            decimal       pesoNeto, peso, pesoBruto;
            string        corral = string.Empty;
            TipoVentaEnum tipoVenta;

            if (txtFolioTicket.Text.Trim() != string.Empty)
            {
                var salida = new SalidaIndividualPL();
                folioTicket     = int.Parse(txtFolioTicket.Text.Trim());
                pesoNeto        = Convert.ToDecimal(txtPesoNeto.Value);
                pesoBruto       = Convert.ToDecimal(txtPesoBruto.Value);
                numeroDeCabezas = int.Parse(lblNumeroTotalCabezas.Content.ToString().Trim());
                peso            = pesoNeto / numeroDeCabezas;
                corral          = txtCorral.Text;

                if ((string)cmbTipo.SelectedItem == Properties.Resources.SalidaIndividualDeGanado_cmbTipoExterno)
                {
                    tipoVenta = TipoVentaEnum.Externo;
                }
                else
                {
                    tipoVenta = TipoVentaEnum.Propio;
                }

                try
                {
                    var salidaIndividual = new SalidaIndividualInfo
                    {
                        FolioTicket     = folioTicket,
                        PesoBruto       = pesoBruto,
                        Peso            = peso,
                        NumeroDeCabezas = numeroDeCabezas,
                        Organizacion    = organizacionID,
                        Usuario         = usuario,
                        TipoVenta       = tipoVenta,
                        Corral          = corral
                    };


                    MemoryStream stream = salida.GuardarSalidaIndividualGanadoVenta(salidaIndividual);

                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.SalidaIndividualGanado_MensajeGuardadoOK,
                                      MessageBoxButton.OK, MessageImage.Correct);

                    try
                    {
                        if (stream != null)
                        {
                            var exportarPoliza = new ExportarPoliza();
                            exportarPoliza.ImprimirPoliza(stream,
                                                          string.Format("{0} {1}", "Poliza Salida Folio No.",
                                                                        folioTicket));
                        }
                    }
                    catch
                    {
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                          Properties.Resources.SalidaIndividualGanado_MensajeErrorAlImprimirPoliza,
                                          MessageBoxButton.OK, MessageImage.Warning);
                    }

                    _pesoTomado = false;
                    Limpiar();
                }
                catch (ExcepcionServicio ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      ex.Message, MessageBoxButton.OK, MessageImage.Stop);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.SalidaIndividualGanado_MensajeErrorAlGuardar,
                                      MessageBoxButton.OK, MessageImage.Warning);
                    _pesoTomado = false;
                    Limpiar();
                }
            }
        }
        /// <summary>
        /// Método para cancelar
        /// </summary>
        private void Guardar()
        {
            bool guardar = ValidaGuardar();

            if (guardar)
            {
                try
                {
                    SolicitudProductoInfo solicitudGuardar = Contexto;
                    solicitudGuardar.UsuarioIDEntrega      = usuario.UsuarioID;
                    solicitudGuardar.FechaEntrega          = DateTime.Now;
                    solicitudGuardar.UsuarioModificacionID = usuario.UsuarioID;
                    //solicitudGuardar.AlmacenID = almacen.AlmacenID;
                    solicitudGuardar.TipoMovimientoInventario = TipoMovimiento.EntradaAlmacen;

                    int activos   = solicitudGuardar.Detalle.Count(e => e.Activo == EstatusEnum.Activo);
                    int recibidos =
                        solicitudGuardar.Detalle.Count(
                            e => e.EstatusID == Estatus.SolicitudProductoRecibido.GetHashCode());

                    if (activos == recibidos)
                    {
                        solicitudGuardar.EstatusID = Estatus.SolicitudProductoRecibido.GetHashCode();
                    }

                    solicitudGuardar.Detalle = solicitudGuardar.Detalle.Where(e => e.Recibido && e.Editar).ToList();
                    MemoryStream pdf = solicitudProductoBL.GuardarMovimientoInventario(solicitudGuardar);
                    if (pdf != null)
                    {
                        var exportarPoliza = new ExportarPoliza();
                        if (solicitudGuardar.AlmacenID.HasValue)
                        {
                            exportarPoliza.ImprimirPoliza(pdf, string.Format("{0} {1}", "Poliza", TipoPoliza.SalidaTraspaso));
                        }
                        else
                        {
                            exportarPoliza.ImprimirPoliza(pdf,
                                                          string.Format("{0} {1}", "Poliza", TipoPoliza.SalidaConsumo));
                        }
                    }
                    string mensaje = Properties.Resources.RecibirProductoAlmacen_GuardadoConExito;
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], mensaje,
                                      MessageBoxButton.OK,
                                      MessageImage.Correct);
                    Limpiar();
                }
                catch (ExcepcionServicio ex)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      ex.Message, MessageBoxButton.OK,
                                      MessageImage.Stop);
                }
                catch (ExcepcionGenerica)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecibirProductoAlmacen_ErrorGuardar, MessageBoxButton.OK,
                                      MessageImage.Error);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.RecibirProductoAlmacen_ErrorGuardar, MessageBoxButton.OK,
                                      MessageImage.Error);
                }
            }
        }
        private void BtnGuardar_OnClick(object sender, RoutedEventArgs e)
        {
            try
            {
                MuertesEnTransitoPL          muertePl     = new MuertesEnTransitoPL();
                ValidacionesFolioVentaMuerte validaciones = new ValidacionesFolioVentaMuerte();
                List <string> aretes = new List <string>();
                if (muertesEnTransitoInfoSeleccionado == null)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_msgFolioEntrada,
                                      MessageBoxButton.OK, MessageImage.Warning);
                    txtArete.Clear();
                    skAyudaFolioEntrada.AsignarFoco();
                    return;
                }
                if (Animales.Count < muertesEnTransitoInfoSeleccionado.MuertesTransito)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_msgNroAretesEsMenor,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    txtArete.Focus();
                    return;
                }
                if (muertesEnTransitoInfoSeleccionado.MuertesTransito > muertesEnTransitoInfoSeleccionado.CabezasLote)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_msgNoTieneExistencia,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    return;
                }
                if (Contexto.Cliente == null || Contexto.Cliente.CodigoSAP.Length == 0)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_msgSeleccionarProveedor,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    return;
                }
                foreach (AnimalInfo arete in dgAretes.ItemsSource)
                {
                    aretes.Add(arete.Arete);
                }
                validaciones = muertePl.ValidarFolio(muertesEnTransitoInfoSeleccionado.FolioEntrada, organizacionID, aretes);

                if (!validaciones.RegistroCondicionMuerte)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_FolioSinCondicionMuerte,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    InicializarFormulario();
                    skAyudaFolioEntrada.AsignarFoco();
                    return;
                }

                if (validaciones.FolioConMuertesRegistradas)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_FolioConRegistroMuertes,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    InicializarFormulario();
                    skAyudaFolioEntrada.AsignarFoco();
                    return;
                }

                if (!validaciones.EstatusLote)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_LoteInactivo,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    InicializarFormulario();
                    skAyudaFolioEntrada.AsignarFoco();
                    return;
                }

                if (validaciones.Cabezas == 0)
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.MuertesEnTransito_LoteSinCabezas,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    InicializarFormulario();
                    skAyudaFolioEntrada.AsignarFoco();
                    return;
                }
                if (validaciones.AretesInvalidos.Length > 0)
                {
                    var mensajeError = string.Empty;
                    mensajeError = string.Format(Properties.Resources.MuertesEnTransito_AreteConRegistroVentaMuerteTransito, validaciones.AretesInvalidos);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      mensajeError,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    return;
                }
                if (validaciones.AretesActivos.Length > 0)
                {
                    var mensajeError = string.Empty;
                    mensajeError = string.Format(Properties.Resources.MuertesEnTransito_AreteActivoEnInventario, validaciones.AretesActivos);
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      mensajeError,
                                      MessageBoxButton.OK,
                                      MessageImage.Stop);
                    return;
                }

                muertesEnTransitoInfoSeleccionado.Proveedor       = muertesEnTransitoInfoSeleccionado.Cliente.Descripcion;
                muertesEnTransitoInfoSeleccionado.CodigoProveedor = muertesEnTransitoInfoSeleccionado.Cliente.CodigoSAP;

                var    muertesEnTrasnsitoPl = new MuertesEnTransitoPL();
                var    folio   = skAyudaFolioEntrada.Clave;
                string mensaje = string.Empty;
                muertesEnTransitoInfoSeleccionado.UsuarioCreacionID = usuarioID;
                muertesEnTransitoInfoSeleccionado.OrganizacionID    = AuxConfiguracion.ObtenerOrganizacionUsuario();
                MemoryStream stream = muertesEnTrasnsitoPl.Guardar(muertesEnTransitoInfoSeleccionado, Animales);
                mensaje = string.Format(Properties.Resources.MuertesEnTransito_msgGuardar, folio.ToString());

                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  mensaje, MessageBoxButton.OK, MessageImage.Correct);

                try
                {
                    if (stream != null)
                    {
                        var exportarPoliza = new ExportarPoliza();
                        exportarPoliza.ImprimirPoliza(stream,
                                                      string.Format("{0} {1}", "Poliza Salida Folio No.",
                                                                    folio));
                    }
                }
                catch
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.SalidaIndividualGanado_MensajeErrorAlImprimirPoliza,
                                      MessageBoxButton.OK, MessageImage.Warning);
                }

                InicializarFormulario();
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  String.Format("{0}: {1}", Properties.Resources.MuertesEnTransito_msgErrorGuardar, ex.Message),
                                  MessageBoxButton.OK, MessageImage.Error);
            }
        }