Пример #1
0
 /// <summary>
 ///     Obtiene un registro de Entrada Ganado Costeo por su EntradaId
 /// </summary>
 /// <param name="entradaId">Identificador de la entrada</param>
 /// <param name="estatus"> </param>
 /// <returns></returns>
 internal EntradaGanadoCosteoInfo ObtenerPorEntradaGanadoID(int entradaId, EstatusEnum estatus)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters =
             AuxEntradaGanadoCosteoDAL.ObtenerParametrosPorEntradaGanadoID(entradaId, estatus);
         DataSet ds = Retrieve("EntradaGanadoCosteo_ObtenerPorEntradaGanadoID", parameters);
         EntradaGanadoCosteoInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapEntradaGanadoCosteoDAL.ObtenerPorEntradaGanadoID(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);
     }
 }
        /// <summary>
        /// Asigna el proveedor SuKarne al Costo del Ganado
        /// </summary>
        /// <param name="entradaGanadoCosteo"></param>
        private void AsignarProveedorSuKarne300(EntradaGanadoCosteoInfo entradaGanadoCosteo)
        {
            var parametroGeneralBL = new ParametroGeneralBL();
            ParametroGeneralInfo parametroGeneral =
                parametroGeneralBL.ObtenerPorClaveParametro(ParametrosEnum.PolizaSacrificio300.ToString());

            if (parametroGeneral != null)
            {
                var proveedor = new ProveedorInfo
                {
                    CodigoSAP = parametroGeneral.Valor
                };
                var proveedorBL = new ProveedorBL();
                proveedor = proveedorBL.ObtenerPorCodigoSAP(proveedor);
                if (proveedor != null)
                {
                    EntradaGanadoCostoInfo entradaGanadoCosto =
                        entradaGanadoCosteo.ListaCostoEntrada.FirstOrDefault(id => id.Costo.CostoID == 1);
                    if (entradaGanadoCosto != null)
                    {
                        entradaGanadoCosto.Proveedor   = proveedor;
                        entradaGanadoCosto.TieneCuenta = false;
                    }
                }
            }
        }
        /// <summary>
        ///     Metodo que obtiene un registro
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        internal static EntradaGanadoCosteoInfo ObtenerPorID(DataSet ds)
        {
            try
            {
                Logger.Info();
                DataTable dt = ds.Tables[ConstantesDAL.DtDatos];

                EntradaGanadoCosteoInfo entidad =
                    (from info in dt.AsEnumerable()
                     select new EntradaGanadoCosteoInfo
                {
                    EntradaGanadoCosteoID =
                        info.Field <int>("EntradaGanadoCosteoID"),
                    Organizacion =
                        new OrganizacionInfo
                    {
                        OrganizacionID = info.Field <int>("OrganizacionID"),
                        Descripcion = info.Field <string>("Organizacion")
                    },
                    EntradaGanadoID = info.Field <int>("EntradaGanadoID"),
                    Observacion = info.Field <string>("Observacion"),
                    Activo = info.Field <bool>("Activo").BoolAEnum(),
                }).First();

                return(entidad);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Пример #4
0
 /// <summary>
 ///     Metodo para Crear un nuevo registro de EntradaGanadoCosteo
 /// </summary>
 /// <param name="info">Información que será guardada</param>
 internal int Crear(EntradaGanadoCosteoInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxEntradaGanadoCosteoDAL.ObtenerParametrosCrear(info);
         int infoId = Create("EntradaGanadoCosteo_Crear", parameters);
         return(infoId);
     }
     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>
        ///     Metodo que obtiene una lista
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        internal static EntradaGanadoCosteoInfo ObtenerPorSalidaOrganizacion(DataSet ds)
        {
            try
            {
                Logger.Info();
                DataTable dtDetalleEntrada = ds.Tables[0];
                DataTable dtCostoEntrada   = ds.Tables[1];

                List <EntradaDetalleInfo> detalleEntrada =
                    (from info in dtDetalleEntrada.AsEnumerable()
                     select new EntradaDetalleInfo
                {
                    TipoGanado =
                        new TipoGanadoInfo
                    {
                        TipoGanadoID = info.Field <int>("TipoGanadoID"),
                        Descripcion = info.Field <string>("TipoGanado"),
                    },
                    Cabezas = info.Field <int>("Cabezas"),
                    PesoOrigen = info.Field <decimal>("PesoOrigen"),
                    PrecioKilo = info.Field <decimal>("PrecioKilo"),
                    Importe = info.Field <decimal>("Importe")
                }).ToList();

                List <EntradaGanadoCostoInfo> detalleCostoEntrada =
                    (from info in dtCostoEntrada.AsEnumerable()
                     select new EntradaGanadoCostoInfo
                {
                    Costo =
                        new CostoInfo
                    {
                        CostoID = info.Field <int>("CostoID"),
                        Descripcion = info.Field <string>("Costo"),
                        ClaveContable = info.Field <string>("ClaveContable"),
                        Retencion = new RetencionInfo
                        {
                            RetencionID = info.Field <int?>("RetencionID") != null ? info.Field <int>("RetencionID") : 0,
                            Descripcion = info.Field <string>("Retencion") ?? string.Empty
                        }
                    },
                    Importe = info.Field <decimal>("Importe"),
                    TieneCuenta = true
                }).ToList();

                var result = new EntradaGanadoCosteoInfo();
                result.ListaEntradaDetalle = detalleEntrada;
                result.ListaCostoEntrada   = detalleCostoEntrada;

                return(result);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// Valida que los pesos de interface sean correctos
        /// </summary>
        /// <param name="entradaGanadoCosteo"></param>
        /// <param name="pesoNeto"></param>
        private void ValidarPeso(EntradaGanadoCosteoInfo entradaGanadoCosteo, int pesoNeto)
        {
            decimal pesoTotal = entradaGanadoCosteo.ListaEntradaDetalle.Sum(peso => peso.PesoOrigen);

            decimal            diferencia     = pesoNeto - pesoTotal;
            EntradaDetalleInfo entradaDetalle = entradaGanadoCosteo.ListaEntradaDetalle.FirstOrDefault();

            if (entradaDetalle == null)
            {
                entradaDetalle = new EntradaDetalleInfo();
            }
            if (diferencia >= 0)
            {
                entradaDetalle.PesoOrigen += diferencia;
            }
            else
            {
                entradaDetalle.PesoOrigen -= diferencia;
            }
        }
Пример #7
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);
            }
        }
Пример #8
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);
     }
 }
        /// <summary>
        ///     Obtiene parametros para Crear
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosCrear(EntradaGanadoCosteoInfo info)
        {
            try
            {
                Logger.Info();
                var parametros =
                    new Dictionary <string, object>
                {
                    { "@OrganizacionID", info.Organizacion.OrganizacionID },
                    { "@EntradaGanadoID", info.EntradaGanadoID },
                    { "@Activo", info.Activo },
                    { "@UsuarioCreacion", info.UsuarioCreacionID },
                    { "@Observacion", info.Observacion }
                };

                return(parametros);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// Completa lista de Calidad de Ganado
        /// </summary>
        /// <param name="entradaGanadoCosteo"></param>
        private void CompletarCalidadGanado(EntradaGanadoCosteoInfo entradaGanadoCosteo)
        {
            var calidadGanadoBL = new CalidadGanadoBL();
            List <EntradaGanadoCalidadInfo> calidadGanado         = calidadGanadoBL.ObtenerListaCalidadGanado();
            List <EntradaGanadoCalidadInfo> calidadGanadoTraspaso = entradaGanadoCosteo.ListaCalidadGanado
                                                                    .Select(cal => new EntradaGanadoCalidadInfo
            {
                CalidadGanado = cal.CalidadGanado,
                Valor         = cal.Valor
            }).ToList();
            EntradaGanadoCalidadInfo calidad;

            calidadGanado.ForEach(dato =>
            {
                calidad = calidadGanadoTraspaso.FirstOrDefault(id => dato.CalidadGanado.CalidadGanadoID
                                                               == id.CalidadGanado.CalidadGanadoID);
                if (calidad != null)
                {
                    dato.Valor = calidad.Valor;
                }
            });
            entradaGanadoCosteo.ListaCalidadGanado = calidadGanado;
        }
        /// <summary>
        /// Agrupa los costos de ganado de la interfaz
        /// </summary>
        /// <param name="entradaGanadoCosteo"></param>
        /// <param name="organizacionId"></param>
        /// <param name="interfaceSalidaTraspaso"></param>
        /// <param name="interfaceSalidaTraspasoCosto"></param>
        private void AgruparValoresInterfaz(EntradaGanadoCosteoInfo entradaGanadoCosteo, int organizacionId, InterfaceSalidaTraspasoInfo interfaceSalidaTraspaso, List <InterfaceSalidaTraspasoCostoInfo> interfaceSalidaTraspasoCosto)
        {
            var interfaceSalidaBL = new InterfaceSalidaBL();
            var costosAgrupados   = (from costos in entradaGanadoCosteo.ListaCostoEntrada
                                     group costos by costos.Costo.CostoID
                                     into costoAgrupado
                                     let interfaceSalidaCostoInfo = costoAgrupado.FirstOrDefault()
                                                                    let claveContable =
                                         interfaceSalidaBL.ObtenerCuentaInventario(interfaceSalidaCostoInfo.Costo,
                                                                                   organizacionId,
                                                                                   ClaveCuenta.CuentaInventarioIntensivo)
                                         where interfaceSalidaCostoInfo != null
                                         select new EntradaGanadoCostoInfo
            {
                Costo = interfaceSalidaCostoInfo.Costo,
                TieneCuenta = true,
                Importe = costoAgrupado.Sum(cos => cos.Importe),
                CuentaProvision = claveContable.Valor,
                DescripcionCuenta = claveContable.Descripcion,
                Origen = true
            }).ToList();

            entradaGanadoCosteo.ListaCalidadGanado = entradaGanadoCosteo.ListaCalidadGanado
                                                     .GroupBy(calidad => calidad.CalidadGanado.CalidadGanadoID)
                                                     .Select(calidad => new EntradaGanadoCalidadInfo
            {
                CalidadGanado
                    = new CalidadGanadoInfo
                    {
                        CalidadGanadoID = calidad.Key,
                        Calidad         =
                            calidad.Select(cal => cal.CalidadGanado.Calidad).
                            FirstOrDefault(),
                        Descripcion =
                            calidad.Select(cal => cal.CalidadGanado.Descripcion).
                            FirstOrDefault(),
                        Sexo =
                            calidad.Select(
                                id => id.CalidadGanado.Sexo).
                            FirstOrDefault()
                    },
                Valor = calidad.Sum(cal => cal.Valor),
            }).ToList();
            decimal importeGanado =
                costosAgrupados.Where(imp => imp.Costo.CostoID == 1).Select(imp => imp.Importe).FirstOrDefault();
            int cabezas = entradaGanadoCosteo.ListaCalidadGanado.Sum(cab => cab.Valor);

            importeGanado = importeGanado + (320 * cabezas);

            EntradaGanadoCostoInfo costoGanado = costosAgrupados.FirstOrDefault(id => id.Costo.CostoID == 1);
            decimal costosNoGanado             = costosAgrupados.Where(id => id.Costo.CostoID != 1).Sum(imp => imp.Importe);

            importeGanado      += costosNoGanado;
            costoGanado.Importe = importeGanado;
            entradaGanadoCosteo.ListaCostoEntrada = costosAgrupados.Where(id => id.Costo.CostoID == 1).ToList();

            foreach (var entradaDetalle in entradaGanadoCosteo.ListaEntradaDetalle)
            {
                var interfaceDetalle =
                    interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.FirstOrDefault(
                        det => det.TipoGanado.TipoGanadoID == entradaDetalle.TipoGanado.TipoGanadoID);

                if (interfaceDetalle != null)
                {
                    decimal importeGanadoDetalle =
                        interfaceSalidaTraspasoCosto.Where(
                            cos =>
                            cos.InterfaceSalidaTraspasoDetalle.InterfaceSalidaTraspasoDetalleID ==
                            interfaceDetalle.InterfaceSalidaTraspasoDetalleID &&
                            cos.Costo.CostoID == Costo.CostoGanado.GetHashCode()).Sum(cos => cos.Importe);

                    importeGanadoDetalle = importeGanadoDetalle + (320 * entradaDetalle.Cabezas);

                    decimal importeGanadoDetalleNoGanado =
                        interfaceSalidaTraspasoCosto.Where(
                            cos =>
                            cos.InterfaceSalidaTraspasoDetalle.InterfaceSalidaTraspasoDetalleID ==
                            interfaceDetalle.InterfaceSalidaTraspasoDetalleID &&
                            cos.Costo.CostoID != Costo.CostoGanado.GetHashCode()).Sum(cos => cos.Importe);

                    importeGanadoDetalle = importeGanadoDetalle + importeGanadoDetalleNoGanado;

                    entradaDetalle.Importe    = importeGanadoDetalle;
                    entradaDetalle.PrecioKilo = entradaDetalle.Importe / entradaDetalle.PesoOrigen;
                }
            }

            //entradaGanadoCosteo.ListaEntradaDetalle =
            //    entradaGanadoCosteo.ListaEntradaDetalle.GroupBy(tipo => tipo.TipoGanado.TipoGanadoID).Select(
            //        detalle => new EntradaDetalleInfo
            //                       {
            //                           TipoGanado = new TipoGanadoInfo
            //                                            {
            //                                                TipoGanadoID = detalle.Key,
            //                                                Descripcion =
            //                                                    detalle.Select(
            //                                                        des =>
            //                                                        des.TipoGanado.Descripcion).
            //                                                    FirstOrDefault()
            //                                            },
            //                           Cabezas = detalle.Sum(cab => cab.Cabezas),
            //                           PesoOrigen = detalle.Sum(peso => peso.PesoOrigen),
            //                           FechaSalidaInterface =
            //                               detalle.Select(fecha => fecha.FechaSalidaInterface).FirstOrDefault(),
            //                           PrecioKilo = importeGanado / detalle.Sum(peso => peso.PesoOrigen),
            //                           Importe =
            //                               (importeGanado / detalle.Sum(peso => peso.PesoOrigen)) *
            //                               detalle.Sum(peso => peso.PesoOrigen)
            //                       }).ToList();
        }
        /// <summary>
        /// Obtiene
        /// </summary>
        /// <param name="organizacionID"> </param>
        /// <param name="folioOrigen"> </param>
        /// <returns></returns>
        internal EntradaGanadoCosteoInfo ObtenerDatosInterfaceSalidaTraspaso(int organizacionID, int folioOrigen)
        {
            EntradaGanadoCosteoInfo entradaGanadoCosteo = null;

            try
            {
                Logger.Info();
                var interfaceSalidaTraspaspBl = new InterfaceSalidaTraspasoDAL();
                InterfaceSalidaTraspasoInfo interfaceSalidaTraspaso =
                    interfaceSalidaTraspaspBl.ObtenerDatosInterfaceSalidaTraspaso(organizacionID, folioOrigen);
                if (interfaceSalidaTraspaso != null)
                {
                    entradaGanadoCosteo = new EntradaGanadoCosteoInfo
                    {
                        ListaCalidadGanado  = new List <EntradaGanadoCalidadInfo>(),
                        ListaCostoEntrada   = new List <EntradaGanadoCostoInfo>(),
                        ListaEntradaDetalle = new List <EntradaDetalleInfo>(),
                    };
                    var animalBL = new AnimalBL();
                    var interfaceSalidaTraspasoCostoBL = new InterfaceSalidaTraspasoCostoBL();
                    List <InterfaceSalidaTraspasoCostoInfo> interfaceSalidaTraspasoCosto =
                        interfaceSalidaTraspasoCostoBL.ObtenerCostosInterfacePorDetalle(interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle);
                    var animalesID = new HashSet <long>(interfaceSalidaTraspasoCosto.Select(id => id.AnimalID));
                    List <AnimalInfo> animalesTraspaso = animalesID.Select(ani => new AnimalInfo
                    {
                        AnimalID = ani,
                        Activo   = false
                    }).ToList();
                    List <AnimalInfo> animalesMovimientoSalidaTraspaso = animalBL.ObtenerMovimientosPorXML(animalesTraspaso);
                    if (animalesMovimientoSalidaTraspaso != null && animalesMovimientoSalidaTraspaso.Any())
                    {
                        var animalesMovimiento = new List <AnimalMovimientoInfo>();
                        animalesMovimientoSalidaTraspaso.ForEach(
                            movs => animalesMovimiento.AddRange(movs.ListaAnimalesMovimiento));

                        int     pesoNeto     = interfaceSalidaTraspaso.PesoBruto - interfaceSalidaTraspaso.PesoTara;
                        decimal pesoLote     = 0;
                        int     totalCabezas = interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Sum(cab => cab.Cabezas);

                        var costoBL = new CostoBL();
                        IList <CostoInfo> costos = costoBL.ObtenerTodos(EstatusEnum.Activo);
                        int cabezas = interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Sum(cabe => cabe.Cabezas);
                        entradaGanadoCosteo.ListaCalidadGanado.AddRange(
                            animalesMovimientoSalidaTraspaso.GroupBy(tipo => tipo.TipoGanado.TipoGanadoID).Select(
                                calidad => new EntradaGanadoCalidadInfo
                        {
                            CalidadGanado
                                = new CalidadGanadoInfo
                                {
                                    CalidadGanadoID =
                                        calidad.Select(
                                            id =>
                                            id.CalidadGanado.CalidadGanadoID).
                                        FirstOrDefault(),
                                    Calidad     = calidad.Select(cal => cal.CalidadGanado.Calidad).FirstOrDefault(),
                                    Descripcion = calidad.Select(cal => cal.CalidadGanado.Descripcion).FirstOrDefault(),
                                    Sexo        =
                                        calidad.Select(
                                            id => id.CalidadGanado.Sexo).
                                        FirstOrDefault()
                                },
                            Valor = calidad.Count(),
                        }));
                        pesoLote = (pesoNeto * cabezas) / totalCabezas;
                        int pesoPromedio = Convert.ToInt32(pesoLote / totalCabezas);
                        entradaGanadoCosteo.ListaEntradaDetalle.AddRange(
                            interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.GroupBy(tipo => tipo.TipoGanado.TipoGanadoID).Select(
                                detalle => new EntradaDetalleInfo
                        {
                            TipoGanado = new TipoGanadoInfo
                            {
                                TipoGanadoID = detalle.Key,
                                Descripcion  = detalle.Select(des => des.TipoGanado.Descripcion).FirstOrDefault()
                            },
                            Cabezas              = detalle.Select(des => des.Cabezas).FirstOrDefault(),
                            PesoOrigen           = detalle.Select(des => des.Cabezas).FirstOrDefault() * pesoPromedio,
                            FechaSalidaInterface = interfaceSalidaTraspaso.FechaEnvio,
                        }));
                        int pesoTotalAgrupado = Convert.ToInt32(entradaGanadoCosteo.ListaEntradaDetalle.Sum(det => det.PesoOrigen));
                        if (pesoTotalAgrupado != pesoNeto)
                        {
                            int diferencia = pesoNeto - pesoTotalAgrupado;
                            EntradaDetalleInfo primerDetalle = entradaGanadoCosteo.ListaEntradaDetalle.FirstOrDefault();
                            if (primerDetalle != null)
                            {
                                primerDetalle.PesoOrigen = primerDetalle.PesoOrigen + diferencia;
                            }
                        }
                        //entradaGanadoCosteo.ListaEntradaDetalle.AddRange(
                        //    animalesMovimientoSalidaTraspaso.GroupBy(tipo => tipo.TipoGanado.TipoGanadoID).Select(
                        //        detalle => new EntradaDetalleInfo
                        //        {
                        //            TipoGanado = new TipoGanadoInfo
                        //            {
                        //                TipoGanadoID = detalle.Key,
                        //                Descripcion =
                        //                    detalle.Select(
                        //                        des =>
                        //                        des.TipoGanado.Descripcion).
                        //                    FirstOrDefault()
                        //            },
                        //            Cabezas = detalle.Count(),
                        //            PesoOrigen = pesoLote,
                        //            FechaSalidaInterface = interfaceSalidaTraspaso.FechaEnvio,
                        //        }));
                        entradaGanadoCosteo.ListaCostoEntrada.AddRange(interfaceSalidaTraspasoCosto
                                                                       .GroupBy(cos => cos.Costo.CostoID).Select(grp =>
                                                                                                                 new EntradaGanadoCostoInfo
                        {
                            Costo = new CostoInfo
                            {
                                CostoID       = grp.Key,
                                ImporteCosto  = grp.Sum(imp => imp.Importe),
                                ClaveContable = costos.Where(id => id.CostoID == grp.Key)
                                                .Select(clave => clave.ClaveContable)
                                                .FirstOrDefault(),
                                Descripcion = costos.Where(id => id.CostoID == grp.Key)
                                              .Select(desc => desc.Descripcion)
                                              .FirstOrDefault()
                            },
                            Importe = grp.Sum(imp => imp.Importe),
                        }));
                        ValidarPeso(entradaGanadoCosteo, pesoNeto);
                        AgruparValoresInterfaz(entradaGanadoCosteo, organizacionID, interfaceSalidaTraspaso, interfaceSalidaTraspasoCosto);
                        CompletarCalidadGanado(entradaGanadoCosteo);
                        AsignarProveedorSuKarne300(entradaGanadoCosteo);
                    }
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoCosteo);
        }
Пример #13
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);
        }
Пример #14
0
        /// <summary>
        ///     Obtiene una Interface de Salida por SalidaID y OrganizacionID
        /// </summary>
        /// <param name="entradaGanado"></param>
        /// <returns></returns>
        internal EntradaGanadoCosteoInfo ObtenerPorSalidaOrganizacion(EntradaGanadoInfo entradaGanado)
        {
            var entradaGanadoCosteo = new EntradaGanadoCosteoInfo();

            try
            {
                Logger.Info();
                var interfaceSalidaDAL   = new InterfaceSalidaDAL();
                var interfacesSalidaInfo = interfaceSalidaDAL.ObtenerPorSalidaOrganizacion(entradaGanado);
                entradaGanadoCosteo.ListaEntradaDetalle = new List <EntradaDetalleInfo>();
                entradaGanadoCosteo.ListaCostoEntrada   = new List <EntradaGanadoCostoInfo>();

                var diasEstancia = new List <double>();

                var listaEntradaGanadoCostoAuxiliar = new List <EntradaGanadoCostoInfo>();

                var tipoGanadoBL = new TipoGanadoBL();

                List <TipoGanadoInfo> tiposGanado = tipoGanadoBL.ObtenerTodos();

                if (interfacesSalidaInfo == null)
                {
                    return(entradaGanadoCosteo);
                }
                interfacesSalidaInfo.ListaInterfaceDetalle.ForEach(det =>
                {
                    var entradaGanadoDetalle = new EntradaDetalleInfo
                    {
                        TipoGanado           = det.TipoGanado,
                        Cabezas              = det.Cabezas,
                        Importe              = det.Importe,
                        PrecioKilo           = det.PrecioKG,
                        PesoOrigen           = det.ListaInterfaceSalidaAnimal.Sum(ani => ani.PesoOrigen),
                        ListaTiposGanado     = tiposGanado,
                        FechaSalidaInterface = interfacesSalidaInfo.FechaSalida,
                    };
                    entradaGanadoCosteo.ListaEntradaDetalle.Add(entradaGanadoDetalle);
                    if (det.ListaInterfaceSalidaAnimal != null)
                    {
                        det.ListaInterfaceSalidaAnimal.ForEach(animal =>
                        {
                            if (animal.ListaSalidaCostos != null)
                            {
                                var listaCostosAnimal = (from costo in animal.ListaSalidaCostos

                                                         select new EntradaGanadoCostoInfo
                                {
                                    Costo = costo.Costo,
                                    Importe = costo.Importe,
                                    TieneCuenta = true,
                                    //CuentaProvision = claveContable.Valor,
                                    //DescripcionCuenta = claveContable.Descripcion
                                });
                                listaEntradaGanadoCostoAuxiliar.AddRange(listaCostosAnimal);

                                var span = interfacesSalidaInfo.FechaSalida - animal.FechaCompra;
                                diasEstancia.Add(span.TotalDays);
                            }
                        });
                    }
                });

                var costosAgrupados = (from costos in listaEntradaGanadoCostoAuxiliar
                                       group costos by costos.Costo.CostoID
                                       into costoAgrupado
                                       let interfaceSalidaCostoInfo = costoAgrupado.FirstOrDefault()
                                                                      let claveContable =
                                           ObtenerCuentaInventario(interfaceSalidaCostoInfo.Costo,
                                                                   entradaGanado.
                                                                   OrganizacionOrigenID, ClaveCuenta.CuentaInventarioTransito)
                                           where interfaceSalidaCostoInfo != null
                                           select new EntradaGanadoCostoInfo
                {
                    Costo = interfaceSalidaCostoInfo.Costo,
                    TieneCuenta = true,
                    Importe = costoAgrupado.Sum(cos => cos.Importe),
                    CuentaProvision = claveContable.Valor,
                    DescripcionCuenta = claveContable.Descripcion,
                    Origen = true
                }).ToList();

                entradaGanadoCosteo.ListaCostoEntrada.AddRange(costosAgrupados);
                entradaGanadoCosteo.DiasEstancia = Convert.ToInt32(diasEstancia.Average());
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoCosteo);
        }
Пример #15
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);
        }
        /// <summary>
        ///     Metodo que obtiene una lista
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        internal static EntradaGanadoCosteoInfo ObtenerPorEntradaGanadoID(DataSet ds)
        {
            try
            {
                Logger.Info();
                DataTable dtEntradaGanado  = ds.Tables[ConstantesDAL.DtDatos];
                DataTable dtCalidad        = ds.Tables[ConstantesDAL.DtDetalleCalidadGanado];
                DataTable dtDetalleEntrada = ds.Tables[ConstantesDAL.DtDetalleTipoGanado];
                DataTable dtCostoEntrada   = ds.Tables[ConstantesDAL.DtDetalleCostoEntrada];

                EntradaGanadoCosteoInfo result =
                    (from info in dtEntradaGanado.AsEnumerable()
                     select new EntradaGanadoCosteoInfo
                {
                    EntradaGanadoCosteoID = info.Field <int>("EntradaGanadoCosteoID"),
                    Organizacion =
                        new OrganizacionInfo
                    {
                        OrganizacionID = info.Field <int>("OrganizacionID"),
                        Descripcion = info.Field <string>("Organizacion")
                    },
                    EntradaGanadoID = info.Field <int>("EntradaGanadoID"),
                    Observacion = info.Field <string>("Observacion"),
                    Activo = info.Field <bool>("Activo").BoolAEnum(),
                }).FirstOrDefault();

                List <EntradaGanadoCalidadInfo> detalleCalidadGanado =
                    (from info in dtCalidad.AsEnumerable()
                     select new EntradaGanadoCalidadInfo
                {
                    EntradaGanadoCalidadID =
                        info.Field <int?>("EntradaGanadoCalidadID") == null
                                            ? 0
                                            : info.Field <int>("EntradaGanadoCalidadID"),
                    CalidadGanado =
                        new CalidadGanadoInfo
                    {
                        CalidadGanadoID = info.Field <int>("CalidadGanadoID"),
                        Descripcion = info.Field <string>("CalidadGanado"),
                        Sexo = Convert.ToChar(info.Field <string>("Sexo")) == 'M'
                                                           ? Sexo.Macho
                                                           : Sexo.Hembra,
                        Calidad = info.Field <string>("Calidad")
                    },
                    Valor = info.Field <int?>("Valor") == null ? 0 : info.Field <int>("Valor"),
                    EntradaGanadoID =
                        info.Field <int?>("EntradaGanadoID") == null
                                            ? 0
                                            : info.Field <int>("EntradaGanadoID"),
                    Activo =
                        info.Field <bool?>("Activo") == null
                                            ? EstatusEnum.Inactivo
                                            : info.Field <bool>("Activo").BoolAEnum(),
                }).ToList();


                List <EntradaDetalleInfo> detalleEntrada =
                    (from info in dtDetalleEntrada.AsEnumerable()
                     select new EntradaDetalleInfo
                {
                    EntradaDetalleID = info.Field <int>("EntradaDetalleID"),
                    EntradaGanadoCosteoID = info.Field <int>("EntradaGanadoCosteoID"),
                    TipoGanado =
                        new TipoGanadoInfo
                    {
                        TipoGanadoID = info.Field <int>("TipoGanadoID"),
                        Descripcion = info.Field <string>("TipoGanado"),
                    },
                    Cabezas = info.Field <int>("Cabezas"),
                    PesoOrigen = info.Field <decimal>("PesoOrigen"),
                    PesoLlegada = info.Field <decimal>("PesoLlegada"),
                    PrecioKilo = info.Field <decimal>("PrecioKilo"),
                    Importe = info.Field <decimal>("Importe"),
                    ImporteOrigen = info.Field <decimal>("ImporteOrigen"),
                    Activo = info.Field <bool>("Activo").BoolAEnum(),
                }).ToList();

                List <EntradaGanadoCostoInfo> detalleCostoEntrada =
                    (from info in dtCostoEntrada.AsEnumerable()
                     select new EntradaGanadoCostoInfo
                {
                    EntradaGanadoCostoID = info.Field <int>("EntradaGanadoCostoID"),
                    EntradaGanadoCosteoID = info.Field <int>("EntradaGanadoCosteoID"),
                    Costo =
                        new CostoInfo
                    {
                        CostoID = info.Field <int>("CostoID"),
                        Descripcion = info.Field <string>("Costo"),
                        ClaveContable = info.Field <string>("ClaveContable"),
                        Retencion = new RetencionInfo
                        {
                            RetencionID = info.Field <int?>("RetencionID") != null ? info.Field <int>("RetencionID") : 0,
                            Descripcion = info.Field <string>("RetencionDescripcion") ?? string.Empty
                        }
                    },
                    TieneCuenta = info.Field <bool>("TieneCuenta"),
                    Proveedor =
                        new ProveedorInfo
                    {
                        ProveedorID = info.Field <int?>("ProveedorID") != null ? info.Field <int>("ProveedorID") : 0,
                        Descripcion = info.Field <string>("Proveedor") ?? string.Empty,
                        CodigoSAP = info.Field <string>("CodigoSAP") ?? string.Empty
                    },
                    NumeroDocumento = info.Field <string>("NumeroDocumento"),
                    Importe = info.Field <decimal>("Importe"),
                    Iva = info.Field <bool>("Iva"),
                    Retencion = info.Field <bool>("Retencion"),
                    Activo = info.Field <bool>("Activo").BoolAEnum(),
                    CuentaProvision = info.Field <string>("CuentaProvision") ?? string.Empty,
                    DescripcionCuenta = info.Field <string>("CuentraProvisionDescripcion") ?? string.Empty,
                }).ToList();
                if (result == null)
                {
                    result = new EntradaGanadoCosteoInfo();
                }
                result.ListaCalidadGanado  = detalleCalidadGanado;
                result.ListaEntradaDetalle = detalleEntrada;
                result.ListaCostoEntrada   = detalleCostoEntrada;

                return(result);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }