예제 #1
0
 /// <summary>
 /// Metodo para Guardar/Modificar una Entrada Ganado Costeo
 /// </summary>
 /// <param name="filtroCalificacionGanadoInfo"></param>
 public void GuardarCalidadGanado(FiltroCalificacionGanadoInfo filtroCalificacionGanadoInfo)
 {
     try
     {
         Logger.Info();
         var entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();
         entradaGanadoCosteoBL.GuardarCalidadGanado(filtroCalificacionGanadoInfo);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #2
0
        /// <summary>
        ///     Obtiene una Entrada Ganado Costeo por su Entrada Id
        /// </summary>
        /// <param name="entradaID"></param>
        /// <returns></returns>
        public EntradaGanadoCosteoInfo ObtenerPorEntradaID(int entradaID)
        {
            try
            {
                Logger.Info();
                var entradaGanadoCosteoBL      = new EntradaGanadoCosteoBL();
                EntradaGanadoCosteoInfo result = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaID);

                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #3
0
 /// <summary>
 /// Obtiene una lista de entradas ganado costeo
 /// </summary>
 /// <param name="organizacionID"></param>
 /// <param name="fechaInicial"></param>
 /// <param name="fechaFinal"></param>
 /// <returns></returns>
 public List <EntradaGanadoCosteoInfo> ObtenerEntradasPorFechasConciliacion(int organizacionID, DateTime fechaInicial, DateTime fechaFinal)
 {
     try
     {
         Logger.Info();
         var entradaGanadoCosteoBL             = new EntradaGanadoCosteoBL();
         List <EntradaGanadoCosteoInfo> result =
             entradaGanadoCosteoBL.ObtenerEntradasPorFechasConciliacion(organizacionID, fechaInicial, fechaFinal);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #4
0
 /// <summary>
 /// Obtener muerte de ganado intensivo
 /// </summary>
 /// <param name="corral"></param>
 /// <returns></returns>
 internal GanadoIntensivoInfo ObtenerMuerteGanadoIntensivo(CorralInfo corral)
 {
     try
     {
         Logger.Info();
         var muerteGanadoIntensivoDAL = new GanadoIntensivoDAL();
         GanadoIntensivoInfo muerteGanadoIntensivoInfo = new GanadoIntensivoInfo();
         var      loteBL                = new LoteBL();
         var      entradaGanadoBL       = new EntradaGanadoBL();
         var      entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();
         LoteInfo lote = loteBL.ObtenerLotesActivos(corral.Organizacion.OrganizacionID, corral.CorralID);
         if (lote != null)
         {
             muerteGanadoIntensivoInfo.Lote         = lote;
             muerteGanadoIntensivoInfo.TotalCabezas = lote.Cabezas;
             var entrada = entradaGanadoBL.ObtenerEntradaGanadoLoteCorral(lote);
             if (entrada != null)
             {
                 muerteGanadoIntensivoInfo.EntradaGanado = entrada;
                 EntradaGanadoCosteoInfo entradaGanadoCosteo = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entrada.EntradaGanadoID);
                 if (entradaGanadoCosteo != null)
                 {
                     muerteGanadoIntensivoInfo.EntradaGanadoCosteo = entradaGanadoCosteo;
                 }
             }
         }
         return(muerteGanadoIntensivoInfo);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #5
0
 /// <summary>
 /// Metodo para Guardar/Modificar una Entrada Ganado Costeo
 /// </summary>
 /// <param name="contenedorCosteoEntradaGanadoInfo"></param>
 public MemoryStream Guardar(ContenedorCosteoEntradaGanadoInfo contenedorCosteoEntradaGanadoInfo)
 {
     try
     {
         Logger.Info();
         var          entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();
         MemoryStream stream = entradaGanadoCosteoBL.Guardar(contenedorCosteoEntradaGanadoInfo);
         return(stream);
     }
     catch (ExcepcionServicio)
     {
         throw;
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
예제 #6
0
        /// <summary>
        /// Obtiene los valores para la reimpresion de
        /// la poliza de entrada de ganado
        /// </summary>
        /// <param name="entradaGanado"></param>
        /// <param name="polizaClave"> </param>
        private MemoryStream ReimprimirPolizaEntrada(EntradaGanadoInfo entradaGanado, TipoPolizaInfo polizaClave)
        {
            EntradaGanadoCosteoInfo entradaGanadoCosteo;
            var esGanadera            = false;
            var entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();

            if (entradaGanado.TipoOrigen == TipoOrganizacion.Ganadera.GetHashCode())
            {
                var interfaceSalidaTraspasoBL = new InterfaceSalidaTraspasoBL();
                entradaGanadoCosteo =
                    interfaceSalidaTraspasoBL.ObtenerDatosInterfaceSalidaTraspaso(entradaGanado.OrganizacionID, entradaGanado.FolioOrigen);
                esGanadera = true;

                EntradaGanadoCosteoInfo entradaGanadoCosteoComplementoCostos
                    = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
                entradaGanadoCosteo.ListaCostoEntrada.AddRange(entradaGanadoCosteoComplementoCostos.ListaCostoEntrada.Where(id => id.Costo.CostoID != 1));
            }
            else
            {
                entradaGanadoCosteo = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
            }

            MemoryStream pdf = null;

            if (entradaGanadoCosteo != null)
            {
                if (!esGanadera)
                {
                    var          cuentaPL          = new CuentaBL();
                    const string CUENTA_INVENTARIO = "CTAINVTRAN";
                    entradaGanadoCosteo.ListaCostoEntrada.ForEach(costo =>
                    {
                        if (!string.IsNullOrWhiteSpace(costo.DescripcionCuenta))
                        {
                            return;
                        }
                        var claveContable = cuentaPL.ObtenerPorClaveCuentaOrganizacion(CUENTA_INVENTARIO,
                                                                                       entradaGanado.OrganizacionOrigenID);
                        if (claveContable != null)
                        {
                            costo.DescripcionCuenta = claveContable.Descripcion;
                        }
                    });
                }
                var contenedorCosteoEntrada = new ContenedorCosteoEntradaGanadoInfo
                {
                    EntradaGanado       = entradaGanado,
                    EntradaGanadoCosteo = entradaGanadoCosteo
                };
                PolizaAbstract poliza;
                var            tipoPoliza = esGanadera ? TipoPoliza.EntradaGanadoDurango : TipoPoliza.EntradaGanado;
                if (esGanadera)
                {
                    poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                }
                else
                {
                    poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                }
                var polizaBL       = new PolizaBL();
                int organizacionID = entradaGanado.OrganizacionID;

                IList <PolizaInfo> polizasEntrada = polizaBL.ObtenerPoliza(tipoPoliza, organizacionID,
                                                                           entradaGanado.FechaEntrada,
                                                                           entradaGanado.FolioEntrada.ToString(),
                                                                           polizaClave.ClavePoliza, 1);
                if (polizasEntrada != null)
                {
                    polizasEntrada = poliza.GeneraPoliza(contenedorCosteoEntrada);
                    pdf            = poliza.ImprimePoliza(contenedorCosteoEntrada, polizasEntrada);
                }
            }
            return(pdf);
        }
예제 #7
0
        internal Dictionary <int, decimal> ObtenerCostoFleteProrrateado(EntradaGanadoInfo entradaGanado, List <EntradaGanadoCostoInfo> listaCostosEmbarque, List <EntradaGanadoInfo> listaCompraDirecta)
        {
            var pesosOrigen         = new Dictionary <int, decimal>();
            var importesProrrateado = new Dictionary <int, decimal>();

            var interfaceSalidaDAL = new InterfaceSalidaDAL();
            List <InterfaceSalidaInfo> listaInterfaceSalida = null;

            listaInterfaceSalida = listaCompraDirecta.Any() ?
                                   interfaceSalidaDAL.ObtenerPorEmbarqueIDConCompraDirecta(entradaGanado) :
                                   interfaceSalidaDAL.ObtenerPorEmbarqueID(entradaGanado);


            if (listaInterfaceSalida == null)
            {
                return(null);
            }

            entradaGanado.ListaInterfaceSalida = listaInterfaceSalida;

            var detalles = listaInterfaceSalida.SelectMany(isa => isa.ListaInterfaceDetalle).SelectMany(isd => isd.ListaInterfaceSalidaAnimal);

            var pesosDetalles = (from isa in detalles
                                 group isa by isa.SalidaID
                                 into agrupado
                                 select new
            {
                SalidaID = agrupado.Key,
                PesoOrigen = agrupado.Sum(animal => animal.PesoCompra)
            }).ToList();

            pesosDetalles.ForEach(pesos => pesosOrigen.Add(pesos.SalidaID, pesos.PesoOrigen));

            if (!pesosDetalles.Any())
            {
                return(null);
            }

            decimal pesoTotalOrigen = pesosDetalles.Sum(pes => pes.PesoOrigen);
            decimal pesoEscala      = 0;

            if (entradaGanado.TipoOrigen != (int)TipoOrganizacion.CompraDirecta)
            {
                pesoEscala = pesosOrigen[entradaGanado.FolioOrigen];

                if (listaCompraDirecta.Any())
                {
                    //Obtener Los pesos de las compras directas ya costeadas
                    var     entradaGanadoCosteoBL        = new EntradaGanadoCosteoBL();
                    var     entradaGanadoCosteoInfo      = new EntradaGanadoCosteoInfo();
                    decimal pesoTotalOrigenCompraDirecta = 0;

                    foreach (var compraDirecta in listaCompraDirecta)
                    {
                        pesoTotalOrigenCompraDirecta = 0;
                        entradaGanadoCosteoInfo      = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(compraDirecta.EntradaGanadoID);
                        if (entradaGanadoCosteoInfo != null && entradaGanadoCosteoInfo.ListaEntradaDetalle != null &&
                            entradaGanadoCosteoInfo.ListaEntradaDetalle.Any())
                        {
                            pesoTotalOrigenCompraDirecta =
                                (from entradaDetalle in entradaGanadoCosteoInfo.ListaEntradaDetalle
                                 select entradaDetalle.PesoOrigen)
                                .Sum();
                        }
                        pesoTotalOrigen = pesoTotalOrigen + pesoTotalOrigenCompraDirecta;
                    }
                }
            }

            listaCostosEmbarque.ForEach(costos =>
            {
                var costoUnitarioKilo = costos.Importe / pesoTotalOrigen;
                ////TODO:Con el peso escala cuando es compra directa
                decimal costoFlete = Math.Round(costoUnitarioKilo * pesoEscala, 2);

                importesProrrateado.Add(costos.Costo.CostoID, costoFlete);
            });

            return(importesProrrateado);
        }