예제 #1
0
        public int Guardar(GanadoIntensivoInfo ganadoIntensivo)
        {
            try
            {
                int result;
                Logger.Info();

                var ganadoIntensivoDAL = new GanadoIntensivoDAL();
                var loteBL             = new LoteBL();
                result = ganadoIntensivoDAL.Guardar(ganadoIntensivo);
                var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
                {
                    CabezasProcesadas     = ganadoIntensivo.Cabezas,
                    LoteIDOrigen          = ganadoIntensivo.Lote.LoteID,
                    UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
                    LoteIDDestino         = 0
                };
                //loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);


                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #2
0
        /// <summary>
        /// Actualiza el Numero de Cabezas de los Lotes
        /// </summary>
        /// <param name="filtroActualizarCabezasLote"></param>
        /// <returns></returns>
        public CabezasActualizadasInfo ActualizarCabezasProcesadas(
            FiltroActualizarCabezasLote filtroActualizarCabezasLote)
        {
            CabezasActualizadasInfo result = null;

            try
            {
                Logger.Info();
                var loteBL = new LoteBL();
                result = loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
예제 #3
0
        /// <summary>
        /// Guarda la salida por muerte en necropsia
        /// </summary>
        /// <param name="muerte"></param>
        /// <returns></returns>
        internal int GuardarSalidaPorMuerteNecropsia(MuerteInfo muerte)
        {
            int retValue;

            try
            {
                Logger.Info();
                var                animalBL             = new AnimalBL();
                var                animalMovimientoBL   = new AnimalMovimientoBL();
                var                corralBL             = new CorralBL();
                var                loteBL               = new LoteBL();
                var                trampaBL             = new TrampaBL();
                var                entradaGanadoBL      = new EntradaGanadoBL();
                var                animalMovimientoInfo = new AnimalMovimientoInfo();
                var                corralInfo           = new CorralInfo();
                var                muerteDAL            = new MuerteDAL();
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaSalidaMuerte;

                AnimalInfo animalInfo = null;
                using (var transaccion = new TransactionScope())
                {
                    //Se obtiene la info del Corral
                    if (muerte.CorralId > 0)
                    {
                        corralInfo = corralBL.ObtenerPorId(muerte.CorralId);
                    }
                    else if (muerte.CorralCodigo != "")
                    {
                        corralInfo = corralBL.ObtenerCorralPorCodigo(muerte.OrganizacionId,
                                                                     muerte.CorralCodigo);
                    }
                    //Se obtiene la info del Lote
                    LoteInfo loteInfo;
                    if (muerte.LoteId > 0)
                    {
                        loteInfo = loteBL.ObtenerPorID(muerte.LoteId);
                    }
                    else
                    {
                        loteInfo = loteBL.DeteccionObtenerPorCorral(muerte.OrganizacionId, corralInfo.CorralID);
                    }
                    /* Se valida el Grupo del corral */
                    switch (corralInfo.GrupoCorral)
                    {
                    case (int)GrupoCorralEnum.Recepcion:
                        /* almacena el animal en el Inventario   */
                        animalInfo = new AnimalInfo
                        {
                            Arete                 = muerte.Arete,
                            AreteMetalico         = muerte.AreteMetalico,
                            FechaCompra           = DateTime.Now,
                            TipoGanadoID          = 1,
                            CalidadGanadoID       = 1, //***
                            ClasificacionGanadoID = 1, //***
                            PesoCompra            = 0,
                            PesoLlegada           = 0, //***
                            FolioEntrada          = 1,
                            OrganizacionIDEntrada = muerte.OrganizacionId,
                            Paletas               = 0,
                            Venta                 = false,
                            Cronico               = false,
                            Activo                = true,
                            UsuarioCreacionID     = muerte.UsuarioCreacionID
                        };

                        var interfazAnimalBl          = new InterfaceSalidaAnimalBL();
                        var interfaceSalidoAnimalInfo =
                            interfazAnimalBl.ObtenerNumeroAreteIndividual(muerte.Arete, muerte.OrganizacionId);
                        int folioEntradaInterfaz = 0;
                        if (interfaceSalidoAnimalInfo != null)
                        {
                            animalInfo.FechaCompra  = interfaceSalidoAnimalInfo.FechaCompra;
                            animalInfo.PesoCompra   = (int)interfaceSalidoAnimalInfo.PesoCompra;
                            animalInfo.TipoGanadoID = interfaceSalidoAnimalInfo.TipoGanado.TipoGanadoID;
                            folioEntradaInterfaz    = interfaceSalidoAnimalInfo.Partida;
                        }

                        EntradaGanadoInfo entradaGanadoInterfaz =
                            entradaGanadoBL.ObtenerEntradasGanadoCosteado(folioEntradaInterfaz, muerte.OrganizacionId);

                        /* Obtener la entrada de ganado del Corral-Lote para conocer el origen */
                        EntradaGanadoInfo entradaGanadoInfo = entradaGanadoBL.ObtenerEntradaPorLote(loteInfo);
                        if (entradaGanadoInfo != null)
                        {
                            if (entradaGanadoInterfaz != null)
                            {
                                if (entradaGanadoInfo.EmbarqueID == entradaGanadoInterfaz.EmbarqueID)
                                {
                                    animalInfo.FolioEntrada = entradaGanadoInterfaz.FolioEntrada;
                                }
                            }
                            if (animalInfo.FolioEntrada == 1)
                            {
                                if (!entradaGanadoInfo.EsRuteo)
                                {
                                    animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
                                }
                                else
                                {
                                    List <CabezasPartidasModel> partidasRuteo =
                                        entradaGanadoBL.ObtenerCabezasEntradasRuteo(entradaGanadoInfo.EmbarqueID);
                                    if (partidasRuteo != null && partidasRuteo.Any())
                                    {
                                        CabezasPartidasModel partidaConPendientes =
                                            partidasRuteo.OrderByDescending(part => part.CabezasPendientes).
                                            FirstOrDefault();
                                        if (partidaConPendientes != null)
                                        {
                                            animalInfo.FolioEntrada = partidaConPendientes.FolioEntrada;
                                        }
                                    }
                                }
                            }
                            //if (entradaGanadoInfo.TipoOrganizacionOrigenId != (int)TipoOrganizacion.CompraDirecta)
                            //{

                            //}
                            //animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
                        }
                        /* Se almacena el animalMovimiento */
                        animalInfo = animalBL.GuardarAnimal(animalInfo);
                        break;

                    default:
                        if (muerte.AnimalId > 0)
                        {
                            animalInfo = animalBL.ObtenerAnimalAnimalID(muerte.AnimalId);
                            /* Se busca el animal En Salida Animal */
                            AnimalSalidaInfo animalSalidaInfo =
                                animalBL.ObtenerAnimalSalidaAnimalID(animalInfo.AnimalID);
                            if (animalSalidaInfo != null)
                            {
                                /* Se valida si no esta en una corraleta de sacrificio */
                                CorralInfo corraleta = corralBL.ObtenerPorId(animalSalidaInfo.CorraletaId);
                                if (corraleta != null &&
                                    corraleta.TipoCorral.TipoCorralID == (int)TipoCorral.CorraletaSacrificio)
                                {
                                    /* Se disminuyen las cabezas del lote en todas las ordenes de sacrificio   */
                                    var ordenSacrificioBL = new OrdenSacrificioBL();
                                    ordenSacrificioBL.DecrementarAnimalMuerto(muerte.AnimalId);
                                    /* Eliminar AnimalSalida */
                                    animalBL.EliminarAnimalSalida(animalInfo.AnimalID, loteInfo.LoteID);
                                }
                            }
                        }
                        else
                        {
                            var listaAnimales = animalBL.ObtenerAnimalesPorCorral(corralInfo, muerte.OrganizacionId);
                            if (listaAnimales != null)     //&& listaAnimales.Any())
                            {
                                //animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
                                animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
                                if (animalInfo == null)
                                {
                                    animalInfo = listaAnimales.OrderBy(ani => ani.AnimalID).FirstOrDefault();
                                }
                            }
                        }
                        break;
                    }

                    if (animalInfo != null)
                    {
                        animalInfo.UsuarioCreacionID     = muerte.UsuarioCreacionID;
                        animalInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
                        if (muerte.AnimalId == 0)
                        {
                            muerte.AnimalId = animalInfo.AnimalID;
                        }
                    }

                    /* Se actualiza la muerte con salida por necropsia */
                    muerteDAL.GuardarSalidaPorMuerteNecropsia(muerte);
                    if (animalInfo != null)
                    {
                        if (muerte.Peso == 0)
                        {
                            List <AnimalMovimientoInfo> ultimosMovimiento = animalMovimientoBL.ObtenerUltimoMovimientoAnimal(new List <AnimalInfo> {
                                animalInfo
                            });
                            if (ultimosMovimiento != null && ultimosMovimiento.Any())
                            {
                                AnimalMovimientoInfo ultimoMovimientoAnimal =
                                    ultimosMovimiento.OrderByDescending(ani => ani.AnimalMovimientoID).FirstOrDefault();

                                if (ultimoMovimientoAnimal != null)
                                {
                                    muerte.Peso = ultimoMovimientoAnimal.Peso;
                                }
                            }
                        }
                        /* Insertamos el movimiento de Muerte */
                        var trampaInfo = trampaBL.ObtenerPorHostName(TrampaGlobal.TrampaNecropsia.ToString());
                        if (trampaInfo != null)
                        {
                            animalMovimientoInfo.TrampaID = trampaInfo.TrampaID;
                        }
                        /* Se genera el animal Movimiento para almacenarlo*/
                        animalMovimientoInfo = new AnimalMovimientoInfo
                        {
                            AnimalID          = animalInfo.AnimalID,
                            OrganizacionID    = muerte.OrganizacionId,
                            CorralID          = loteInfo.CorralID,
                            LoteID            = loteInfo.LoteID,
                            Peso              = muerte.Peso,
                            Temperatura       = 0,
                            TipoMovimientoID  = (int)TipoMovimiento.Muerte,
                            TrampaID          = trampaInfo != null ? trampaInfo.TrampaID : 1,
                            OperadorID        = muerte.OperadorNecropsiaId,
                            Observaciones     = muerte.Observaciones,
                            Activo            = EstatusEnum.Activo,
                            UsuarioCreacionID = muerte.UsuarioCreacionID
                        };

                        //Proceso para Guardar Costos
                        AnimalCostoBL     animalCostoBl = new AnimalCostoBL();
                        List <AnimalInfo> animales      = new List <AnimalInfo>();
                        animales.Add(animalInfo);
                        List <AnimalCostoInfo> listaCostos = animalCostoBl.ObtenerCostosAnimal(animales);

                        if (listaCostos == null || listaCostos.Count <= 0)
                        {
                            animales = animalBL.ProcesoGenerarCostos(animales);
                        }
                        else
                        {
                            if (!listaCostos.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
                            {
                                animales = animalBL.ProcesoGenerarCostos(animales);
                            }
                        }

                        //Proceso Armar Poliza
                        if (animales != null && animales.Count > 0)
                        {
                            if (animales.FirstOrDefault().ListaCostosAnimal != null && animales.FirstOrDefault().ListaCostosAnimal.Count > 0)
                            {
                                poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerte);
                                List <AnimalCostoInfo> listaCostosAnimal = animales.FirstOrDefault().ListaCostosAnimal;
                                foreach (AnimalCostoInfo animalCosto in listaCostosAnimal)
                                {
                                    animalCosto.OrganizacionID = muerte.OrganizacionId;
                                }
                                polizaSalidaMuerte = poliza.GeneraPoliza(listaCostosAnimal);
                                if (polizaSalidaMuerte != null && polizaSalidaMuerte.Any())
                                {
                                    polizaSalidaMuerte.ToList().ForEach(
                                        org =>
                                    {
                                        org.OrganizacionID         = muerte.OrganizacionId;
                                        org.UsuarioCreacionID      = muerte.UsuarioCreacionID;
                                        org.ArchivoEnviadoServidor = 1;
                                    });
                                    //retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaMuerte);
                                    var polizaBL = new PolizaBL();
                                    polizaBL.GuardarServicioPI(polizaSalidaMuerte, TipoPoliza.SalidaMuerte);
                                }
                            }
                        }

                        /* Se almacena el animalMovimiento */
                        animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);

                        /*  Se da de baja el animal */
                        animalBL.InactivarAnimal(animalInfo);

                        /* Enviar al historico el animal inactivo */
                        var animalMuerto = new List <AnimalInfo> {
                            animalInfo
                        };
                        animalBL.EnviarAHistorico(animalMuerto);
                    }
                    /* Decrementar la cabeza del lote */
                    loteInfo.Cabezas = loteInfo.Cabezas - 1;
                    loteInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
                    var filtro = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = 1,
                        LoteIDDestino         = 0,
                        LoteIDOrigen          = loteInfo.LoteID,
                        UsuarioModificacionID = muerte.UsuarioCreacionID
                    };

                    CabezasActualizadasInfo resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);


                    //Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
                    if (resultadoCabezas.CabezasOrigen <= 0)
                    {
                        if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
                        {
                            /* Si el corral es de Recepcion */
                            var corteGanadoPl = new CorteGanadoBL();
                            corteGanadoPl.ObtenerPesosOrigenLlegada(muerte.OrganizacionId,
                                                                    loteInfo.CorralID,
                                                                    loteInfo.LoteID);
                        }
                    }

                    transaccion.Complete();
                    retValue = 1;
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(retValue);
        }
예제 #4
0
        /// <summary>
        /// Genera los Parametros para la Acutalizacion
        /// de las Cabezas que tiene un Lote
        /// </summary>
        /// <param name="filtroActualizarCabezasLote"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosActualizarCabezasProcesadas(FiltroActualizarCabezasLote filtroActualizarCabezasLote)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@LoteIDOrigen", filtroActualizarCabezasLote.LoteIDOrigen },
                    { "@LoteIDDestino", filtroActualizarCabezasLote.LoteIDDestino },
                    { "@CabezasProcesadas", filtroActualizarCabezasLote.CabezasProcesadas },
                    { "@UsuarioModificacionID", filtroActualizarCabezasLote.UsuarioModificacionID }
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(parametros);
        }
예제 #5
0
        /// <summary>
        /// Guardar muerte de ganado intenvio
        /// </summary>
        /// <param name="ganadoIntensivo"></param>
        /// <returns></returns>
        public GanadoIntensivoInfo MuerteGanadoIntensivo_Guardar(GanadoIntensivoInfo ganadoIntensivo)
        {
            try
            {
                int result;
                Logger.Info();
                MemoryStream        polizaPDF = null;
                GanadoIntensivoInfo resultado = new GanadoIntensivoInfo();
                using (var transaction = new TransactionScope())
                {
                    var                loteBL = new LoteBL();
                    PolizaAbstract     poliza;
                    IList <PolizaInfo> polizaSalidaMuerteIntensiva;
                    result = Guardar(ganadoIntensivo);
                    resultado.FolioTicket       = result;
                    ganadoIntensivo.FolioTicket = result;
                    var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = ganadoIntensivo.Cabezas,
                        LoteIDOrigen          = ganadoIntensivo.Lote.LoteID,
                        UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
                        LoteIDDestino         = 0
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);

                    #region Poliza


                    if (ganadoIntensivo != null)
                    {
                        if (ganadoIntensivo.ListaGanadoIntensivoCosto != null &&
                            ganadoIntensivo.ListaGanadoIntensivoCosto.Any())
                        {
                            poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerteIntensiva);
                            polizaSalidaMuerteIntensiva = poliza.GeneraPoliza(ganadoIntensivo);
                            if (polizaSalidaMuerteIntensiva != null && polizaSalidaMuerteIntensiva.Any())
                            {
                                polizaSalidaMuerteIntensiva.ToList().ForEach(
                                    org =>
                                {
                                    org.OrganizacionID         = ganadoIntensivo.Organizacion.OrganizacionID;
                                    org.UsuarioCreacionID      = ganadoIntensivo.UsuarioCreacionID;
                                    org.ArchivoEnviadoServidor = 1;
                                });
                                polizaPDF = poliza.ImprimePoliza(ganadoIntensivo, polizaSalidaMuerteIntensiva);
                                var polizaBL = new PolizaBL();
                                polizaBL.GuardarServicioPI(polizaSalidaMuerteIntensiva, TipoPoliza.SalidaMuerteIntensiva);
                                resultado.stream = polizaPDF;
                            }
                        }
                    }
                    #endregion Poliza
                    transaction.Complete();
                }

                return(resultado);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// guardar corte por transferencia
        /// </summary>
        /// <param name="guardarAnimalCorte"></param>
        /// <param name="listaTratamientos"></param>
        /// <returns></returns>
        internal CorteTransferenciaGanadoGuardarInfo GuardarCorteTransferencia(CorteTransferenciaGanadoGuardarInfo guardarAnimalCorte, IList <TratamientoInfo> listaTratamientos)
        {
            try
            {
                using (var transaction = new TransactionScope())
                {
                    Logger.Info();
                    //var corteTransferenciaGanado = new CorteTransferenciaGanadoDAL();
                    var animalBl                  = new AnimalBL();
                    var animalMovimientoBL        = new AnimalMovimientoBL();
                    var corralBl                  = new CorralBL();
                    var interfaceSalidaAnimalBl   = new InterfaceSalidaAnimalBL();
                    var interfaceSalidoAnimalInfo =
                        interfaceSalidaAnimalBl.ObtenerNumeroAreteIndividual(
                            guardarAnimalCorte.AnimalCorteTransferenciaInfo.Arete, guardarAnimalCorte.OrganizacionId);

                    if (guardarAnimalCorte.AnimalActualInfo != null)
                    {
                        guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
                            guardarAnimalCorte.AnimalActualInfo.FechaCompra;
                    }
                    else
                    {
                        if (interfaceSalidoAnimalInfo != null)
                        {
                            guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
                                interfaceSalidoAnimalInfo.FechaCompra;
                        }
                    }

                    var resultoAnimalInfo = animalBl.GuardarAnimal(guardarAnimalCorte.AnimalCorteTransferenciaInfo);
                    guardarAnimalCorte.AnimalCorteTransferenciaInfo = resultoAnimalInfo;
                    guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalID =
                        guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID;

                    var loteBl              = new LoteBL();
                    var resultadoLote       = -1;
                    var resultadoLoteOrigen = loteBl.ObtenerPorID(guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
                    var resultadoLoteBL     =
                        loteBl.ObtenerLotesActivos(
                            guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.OrganizacionID,
                            Convert.ToInt32(guardarAnimalCorte.CorralInfoGen.CorralID));
                    if (resultadoLoteBL == null)
                    {
                        //var corralInfo = new CorralInfo
                        //{
                        //    Codigo = guardarAnimalCorte.TxtCorralDestino,
                        //    TipoCorral = new TipoCorralInfo { TipoCorralID = (int)TipoCorral.Improductivos },
                        //    Organizacion = new OrganizacionInfo { OrganizacionID = guardarAnimalCorte.OrganizacionId }
                        //};
                        CorralInfo resultadoCorralPl = corralBl.ObtenerPorId(guardarAnimalCorte.CorralDestinoID);
                        if (resultadoCorralPl != null)
                        {
                            var loteCrear         = new LoteBL();
                            var tipoProcesoBl     = new TipoProcesoBL();
                            var tipoProcesoResult =
                                tipoProcesoBl.ObtenerPorOrganizacion(guardarAnimalCorte.OrganizacionId);
                            var loteInfoLote = new LoteInfo
                            {
                                Activo               = EstatusEnum.Activo,
                                Cabezas              = Convert.ToInt32(0),
                                CabezasInicio        = Convert.ToInt32(0),
                                CorralID             = resultadoCorralPl.CorralID,
                                DisponibilidadManual = false,
                                OrganizacionID       =
                                    guardarAnimalCorte.AnimalMovimientoOrigenInfo.OrganizacionID,
                                TipoCorralID      = resultadoCorralPl.TipoCorral.TipoCorralID,
                                TipoProcesoID     = tipoProcesoResult,
                                UsuarioCreacionID = resultadoCorralPl.UsuarioCreacionID,
                            };
                            resultadoLote = loteCrear.GuardaLote(loteInfoLote);
                            guardarAnimalCorte.LoteDestinoInfo = loteCrear.ObtenerPorID(resultadoLote);
                        }
                    }
                    else
                    {
                        guardarAnimalCorte.LoteDestinoInfo = resultadoLoteBL;
                    }
                    //Se manda a guardar movimiento de salida de enfermeria
                    //var animalSalidaInfo = new AnimalSalidaInfo();
                    //animalSalidaInfo = animalBl.ObtenerAnimalSalidaAnimalID(guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID);

                    //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID = animalSalidaInfo.CorralId;
                    //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = animalSalidaInfo.LoteId;
                    //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID = (int)TipoMovimiento.SalidaEnfermeria;
                    //guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo = animalMovimientoBL.GuardarAnimalMovimiento(guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);

                    //Se manda a guardar movimiento de corte por transferencia
                    guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID =
                        guardarAnimalCorte.CorralInfoGen.CorralID;
                    guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = resultadoLoteBL != null
                        ? resultadoLoteBL.LoteID
                        : resultadoLote;
                    guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID =
                        (int)TipoMovimiento.CortePorTransferencia;
                    guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo =
                        animalMovimientoBL.GuardarAnimalMovimiento(
                            guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);

                    if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null &&
                        guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalMovimientoID > 0)
                    {
                        if (resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
                        {
                            guardarAnimalCorte.CorralGlobal                  = guardarAnimalCorte.AnimalMovimientoOrigenInfo.CorralID;
                            guardarAnimalCorte.LoteDestinoInfo.Cabezas       = guardarAnimalCorte.LoteDestinoInfo.Cabezas + 1;
                            guardarAnimalCorte.LoteDestinoInfo.CabezasInicio =
                                guardarAnimalCorte.LoteDestinoInfo.CabezasInicio + 1;
                            resultadoLoteOrigen.Cabezas = resultadoLoteOrigen.Cabezas - 1;
                            var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                            {
                                LoteIDOrigen          = resultadoLoteOrigen.LoteID,
                                LoteIDDestino         = guardarAnimalCorte.LoteDestinoInfo.LoteID,
                                CabezasProcesadas     = 1,
                                UsuarioModificacionID =
                                    guardarAnimalCorte.UsuarioCreacionID
                            };
                            var cabezas = loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
                            //TODO nuevo metodo
                            //loteBl.ActualizaNoCabezasEnLote(guardarAnimalCorte.LoteDestinoInfo, resultadoLoteOrigen);
                            loteBl.ActualizarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
                            loteBl.ActualizarFechaSalidaEnLote(resultadoLoteOrigen);
                            //if (resultadoLoteOrigen.Cabezas == 0)
                            //{
                            //    resultadoLoteOrigen.Activo = (int)EstatusEnum.Inactivo;
                            //    loteBl.ActualizaActivoEnLote(resultadoLoteOrigen);
                            //}
                            // ObtenerTotalCabezas(loteCorralOrigen);
                        }
                        if (ObtenerTotalCabezas(guardarAnimalCorte.AnimalMovimientoOrigenInfo))
                        {
                            corralBl.TraspasarAnimalSalidaEnfermeria(
                                guardarAnimalCorte.AnimalSalidaGuardarInfo.CorraletaId,
                                guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
                            //loteDAL.EliminarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
                        }
                    }

                    if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null)
                    {
                        var almacenMovimientoInfo = new AlmacenMovimientoInfo
                        {
                            AlmacenID          = guardarAnimalCorte.AlmacenID,
                            AnimalMovimientoID =
                                guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
                                .AnimalMovimientoID,
                            TipoMovimientoID  = (int)TipoMovimiento.SalidaPorConsumo,
                            Status            = (int)EstatusInventario.Aplicado,
                            Observaciones     = "",
                            UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID,
                            AnimalID          =
                                guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
                                .AnimalID,
                            //Verificar
                            CostoID = (int)Costo.MedicamentoDeImplante,
                        };
                        var almacenBL = new AlmacenBL();
                        almacenBL.GuardarDescontarTratamientos(
                            listaTratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList(),
                            almacenMovimientoInfo);
                    }
                    var loteProyeccionBL = new LoteProyeccionBL();
                    LoteProyeccionInfo proyeccionDestino =
                        loteProyeccionBL.ObtenerPorLote(guardarAnimalCorte.LoteDestinoInfo);
                    //guardarAnimalCorte.LoteDestinoInfo.LoteID
                    if (proyeccionDestino == null)
                    {
                        LoteProyeccionInfo proyeccionOrigen = loteProyeccionBL.ObtenerPorLote(resultadoLoteOrigen);

                        if (proyeccionOrigen != null && resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
                        {
                            proyeccionOrigen.LoteProyeccionID = 0;
                            int      diasEngordaOrigen = proyeccionOrigen.DiasEngorda;
                            DateTime fechaInicioLote   = resultadoLoteOrigen.FechaInicio;
                            int      diasEngordaReales =
                                new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days;

                            if ((diasEngordaOrigen - diasEngordaReales) <= 0)
                            {
                                proyeccionOrigen.DiasEngorda = 0;
                            }
                            else
                            {
                                proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales;
                            }

                            proyeccionOrigen.LoteID            = guardarAnimalCorte.LoteDestinoInfo.LoteID;
                            proyeccionOrigen.UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID;
                            loteProyeccionBL.Guardar(proyeccionOrigen);

                            var loteDAL = new LoteDAL();
                            var filtroDisponibilidad = new FiltroDisponilidadInfo
                            {
                                UsuarioId = guardarAnimalCorte.UsuarioCreacionID,
                                ListaLoteDisponibilidad =
                                    new List <DisponibilidadLoteInfo>
                                {
                                    new DisponibilidadLoteInfo
                                    {
                                        LoteId = guardarAnimalCorte.LoteDestinoInfo.LoteID,
                                        FechaDisponibilidad =
                                            resultadoLoteOrigen.FechaDisponibilidad,
                                        DisponibilidadManual =
                                            resultadoLoteOrigen.DisponibilidadManual
                                    }
                                }
                            };
                            loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad);
                        }
                    }

                    transaction.Complete();
                    return(guardarAnimalCorte);
                }
            }
            catch (ExcepcionGenerica)
            {
                return(null);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #7
0
        /// <summary>
        /// Metodo que da salida por venta al ganado intensivo cuano se selcciona tipoventa Externo
        /// </summary>
        /// <param name="salidaIndividual"></param>
        /// <returns></returns>
        internal MemoryStream GuardarSalidaGanadoVentaIntensiva(SalidaIndividualInfo salidaIndividual)
        {
            MemoryStream retorno = null;

            try
            {
                PolizaAbstract      poliza;
                IList <PolizaInfo>  polizaSalidaVenta;
                TicketInfo          Ticket            = new TicketInfo();
                CorralInfo          corralInfo        = new CorralInfo();
                CorralBL            corralB           = new CorralBL();
                GanadoIntensivoBL   salidaGanadoCosto = new GanadoIntensivoBL();
                GanadoIntensivoInfo salidaGanadoInfo  = new GanadoIntensivoInfo();


                corralInfo = corralB.ObtenerCorralActivoPorCodigo(salidaIndividual.Organizacion, salidaIndividual.Corral);
                corralInfo.Organizacion = new OrganizacionInfo();
                corralInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                salidaGanadoInfo = salidaGanadoCosto.ObtenerMuerteGanadoIntensivo(corralInfo);
                salidaGanadoInfo.Organizacion = new OrganizacionInfo();
                salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                salidaGanadoInfo.Observaciones = "";



                Ticket.FolioTicket  = salidaIndividual.FolioTicket;
                Ticket.Organizacion = salidaIndividual.Organizacion;

                var ventaGanadoBL = new VentaGanadoBL();

                VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);

                var      loteBL            = new LoteBL();
                CorralBL corralBl          = new CorralBL();
                LoteInfo lote              = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
                int      iCabezasTotalLote = lote.Cabezas;

                lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
                //lote.Corral = corralBl.ObtenerCorralPorLoteID(lote.LoteID, salidaIndividual.Organizacion);
                //lote.Corral = corralBl.ObtenerCorralPorCodigo()

                using (var scope = new TransactionScope())
                {
                    Logger.Info();
                    var salidaIndividualDAL = new SalidaIndividualDAL();

                    var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                    {
                        LoteIDOrigen          = lote.LoteID,
                        LoteIDDestino         = 0,
                        CabezasProcesadas     = salidaIndividual.NumeroDeCabezas,
                        UsuarioModificacionID = salidaIndividual.Usuario
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                    salidaGanadoInfo.ListaGanadoIntensivoCosto = new List <GanadoIntensivoCostoInfo>();
                    foreach (
                        var entradaCosteo in
                        salidaGanadoInfo.EntradaGanadoCosteo.ListaCostoEntrada.OrderBy(id => id.Costo.CostoID))
                    {
                        var costoInt = new GanadoIntensivoCostoInfo();
                        costoInt.Costos = new CostoInfo();
                        costoInt.Costos = entradaCosteo.Costo;
                        costoInt.Costos.ImporteCosto = (entradaCosteo.Importe /
                                                        salidaGanadoInfo.EntradaGanado.CabezasRecibidas) *
                                                       salidaIndividual.NumeroDeCabezas;
                        costoInt.Importe = costoInt.Costos.ImporteCosto;
                        salidaGanadoInfo.ListaGanadoIntensivoCosto.Add(costoInt);
                    }
                    salidaGanadoInfo.TipoMovimientoID = TipoMovimiento.SalidaVentaIntensivo;
                    //salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
                    salidaGanadoInfo.TotalCabezas                = salidaIndividual.NumeroDeCabezas;
                    salidaGanadoInfo.FolioTicket                 = salidaIndividual.FolioTicket;
                    salidaGanadoInfo.TipoFolio                   = TipoFolio.VentaGanadoIntensivo;
                    salidaGanadoInfo.PesoBruto                   = salidaIndividual.PesoBruto;
                    salidaGanadoInfo.UsuarioCreacionID           = salidaIndividual.Usuario;
                    salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                    salidaGanadoInfo.CabezasText                 = salidaIndividual.NumeroDeCabezas.ToString();
                    salidaGanadoCosto.Guardar(salidaGanadoInfo);

                    #region Poliza

                    List <ContenedorVentaGanado> ventasGanado =
                        ventaGanadoBL.ObtenerVentaGanadoIntensivoPorTicketPoliza(Ticket);

                    if (ventasGanado != null && ventasGanado.Any())
                    {
                        poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaIntensiva);
                        for (int i = 0; i < ventasGanado.Count; i++)
                        {
                            ventasGanado[i].EntradaGandoId = salidaGanadoInfo.EntradaGanado.EntradaGanadoID;
                            ventasGanado[i].OrganizacionId = Ticket.Organizacion;
                            ventasGanado[i].Lote           = lote;
                        }

                        polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
                        if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
                        {
                            polizaSalidaVenta.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = Ticket.Organizacion;
                                org.UsuarioCreacionID      = salidaIndividual.Usuario;
                                org.ArchivoEnviadoServidor = 1;
                            });
                            retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVentaIntensiva);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaVentaDeGanadoIntensivo(Ticket.FolioTicket, Ticket.Organizacion);

                    #endregion Poliza

                    scope.Complete();
                }

                return(retorno);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #8
0
        /// <summary>
        /// Metodo que le da salida por venta al ganado
        /// </summary>
        /// <param name="salidaIndividual"></param>
        /// <returns></returns>
        internal MemoryStream GuardarSalidaIndividualGanadoVenta(SalidaIndividualInfo salidaIndividual)
        {
            MemoryStream retorno = null;

            try
            {
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaSalidaVenta;
                TicketInfo         Ticket = new TicketInfo();

                Ticket.FolioTicket  = salidaIndividual.FolioTicket;
                Ticket.Organizacion = salidaIndividual.Organizacion;
                Ticket.TipoVenta    = salidaIndividual.TipoVenta;

                var ventaGanadoBL = new VentaGanadoBL();

                VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);


                var      loteBL = new LoteBL();
                LoteInfo lote   = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
                lote.Cabezas -= salidaIndividual.NumeroDeCabezas;

                AnimalBL animalBl = new AnimalBL();

                using (var scope = new TransactionScope())
                {
                    Logger.Info();
                    var salidaIndividualDAL = new SalidaIndividualDAL();

                    VentaGanadoDetalleBL          ventaGanadoDetalleBl    = new VentaGanadoDetalleBL();
                    List <VentaGanadoDetalleInfo> listaVentaGanadoDetalle = ventaGanadoDetalleBl.ObtenerVentaGanadoPorTicket(salidaPorVentaGanado.VentaGanadoID);
                    List <AnimalCostoInfo>        animalCosto             = new List <AnimalCostoInfo>();
                    AnimalCostoBL     animalCostoBl    = new AnimalCostoBL();
                    List <AnimalInfo> animalesConsulta = new List <AnimalInfo>();
                    List <AnimalInfo> animalesProcesar = new List <AnimalInfo>();
                    foreach (VentaGanadoDetalleInfo ventaGanado in listaVentaGanadoDetalle)
                    {
                        animalesConsulta   = new List <AnimalInfo>();
                        ventaGanado.Animal = animalBl.ObtenerAnimalPorArete(ventaGanado.Arete, Ticket.Organizacion);

                        if (ventaGanado.Animal == null)
                        {
                            ventaGanado.Animal = animalBl.ObtenerAnimalPorAreteTestigo(ventaGanado.AreteMetalico, Ticket.Organizacion);
                        }
                        animalesConsulta.Add(ventaGanado.Animal);
                        animalCosto = animalCostoBl.ObtenerCostosAnimal(animalesConsulta);

                        if (!animalCosto.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
                        {
                            animalesProcesar.Add(ventaGanado.Animal);
                        }
                    }

                    if (animalesProcesar != null && animalesProcesar.Count > 0)
                    {
                        animalBl.ProcesoGenerarCostos(animalesProcesar);
                    }

                    salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
                    salidaIndividualDAL.GuardarCostosHistoricos(salidaIndividual);
                    salidaIndividualDAL.GuardarConsumoHistoricos(salidaIndividual);
                    salidaIndividualDAL.GuardarAnimalHistoricos(salidaIndividual);

                    var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                    {
                        LoteIDOrigen          = lote.LoteID,
                        LoteIDDestino         = 0,
                        CabezasProcesadas     = salidaIndividual.NumeroDeCabezas,
                        UsuarioModificacionID = salidaIndividual.Usuario
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                    //loteBL.ActualizaNoCabezasEnLote(lote, lote);

                    #region Poliza

                    List <ContenedorVentaGanado> ventasGanado =
                        ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(Ticket.FolioTicket, Ticket.Organizacion);


                    if (ventasGanado != null && ventasGanado.Any())
                    {
                        poliza            = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVenta);
                        polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
                        if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
                        {
                            polizaSalidaVenta.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = Ticket.Organizacion;
                                org.UsuarioCreacionID      = salidaIndividual.Usuario;
                                org.ArchivoEnviadoServidor = 1;
                            });
                            retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVenta);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaVentaDeGanado(Ticket.FolioTicket, Ticket.Organizacion);

                    #endregion Poliza

                    scope.Complete();
                }
                return(retorno);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #9
0
        /// <summary>
        /// Metodo para Guardar/Modificar un Corral
        /// </summary>
        /// <param name="arete"></param>
        /// <param name="organizacion"></param>
        /// <param name="codigoCorral"></param>
        /// <param name="corraletaID"></param>
        /// <param name="usuarioCreacion"></param>
        /// <param name="tipoMovimiento"></param>
        /// <param name="operador"></param>
        internal int Guardar(string arete, int organizacion, string codigoCorral, int corraletaID, int usuarioCreacion, int tipoMovimiento, int operador)
        {
            int retorno = 0;

            try
            {
                Logger.Info();
                var salidaIndividualDAL = new SalidaIndividualDAL();
                var animalBl            = new AnimalBL();
                var corralBl            = new CorralBL();
                var loteBl = new LoteBL();

                using (var transaccion = new TransactionScope())
                {
                    var animal = animalBl.ObtenerAnimalPorArete(arete, organizacion);
                    if (animal != null)
                    {
                        if (tipoMovimiento == TipoMovimiento.SalidaPorRecuperacion.GetHashCode())
                        {
                            var corralOrigen = corralBl.ObtenerCorralPorCodigo(organizacion, codigoCorral);
                            var loteOrigen   = new LoteInfo();
                            if (corralOrigen != null)
                            {
                                loteOrigen = loteBl.DeteccionObtenerPorCorral(organizacion, corralOrigen.CorralID);
                            }

                            var corralDestino = corralBl.ObtenerPorId(corraletaID);
                            var loteDestino   = new LoteInfo();
                            if (corralDestino != null)
                            {
                                loteDestino = loteBl.DeteccionObtenerPorCorral(organizacion, corralDestino.CorralID);
                            }

                            if (corralOrigen != null)
                            {
                                if (loteOrigen != null)
                                {
                                    if (corralDestino != null)
                                    {
                                        if (corralDestino.TipoCorral.TipoCorralID !=
                                            TipoCorral.CorraletaRecuperado.GetHashCode() && corralDestino.TipoCorral.TipoCorralID != TipoCorral.CorraletaRecuperadosPartida.GetHashCode())
                                        {
                                            if (loteDestino != null)
                                            {
                                                var animalMovimientoBl = new AnimalMovimientoBL();

                                                var ultimoMovimiento = animalBl.ObtenerUltimoMovimientoAnimal(animal);

                                                if (ultimoMovimiento != null)
                                                {
                                                    var animalMovimientoOrigen = new AnimalMovimientoInfo
                                                    {
                                                        AnimalID          = animal.AnimalID,
                                                        CorralID          = corralDestino.CorralID,
                                                        LoteID            = loteDestino.LoteID,
                                                        TipoMovimientoID  = tipoMovimiento,
                                                        OperadorID        = operador,
                                                        OrganizacionID    = organizacion,
                                                        TrampaID          = ultimoMovimiento.TrampaID,
                                                        Peso              = ultimoMovimiento.Peso,
                                                        Temperatura       = ultimoMovimiento.Temperatura,
                                                        UsuarioCreacionID = usuarioCreacion
                                                    };
                                                    animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);

                                                    loteOrigen.Cabezas = loteOrigen.Cabezas - 1;

                                                    loteDestino.Cabezas       = loteDestino.Cabezas + 1;
                                                    loteDestino.CabezasInicio = loteDestino.CabezasInicio + 1;

                                                    var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                                                    {
                                                        LoteIDOrigen          = loteOrigen.LoteID,
                                                        LoteIDDestino         = loteDestino.LoteID,
                                                        CabezasProcesadas     = 1,
                                                        UsuarioModificacionID = usuarioCreacion
                                                    };
                                                    loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
                                                }
                                                else
                                                {
                                                    retorno = -1;
                                                }
                                            }
                                            else
                                            {
                                                retorno = -1;
                                            }
                                        }
                                        else
                                        {
                                            var loteBL             = new LoteBL();
                                            var animalMovimientoBl = new AnimalMovimientoBL();
                                            var ultimoMovimiento   = animalBl.ObtenerUltimoMovimientoAnimal(animal);

                                            LoteInfo loteDestinoCorraleta = loteBL.DeteccionObtenerPorCorral(organizacion,
                                                                                                             corralDestino.CorralID);
                                            int loteIDGuardar = 0;
                                            if (loteDestinoCorraleta == null || loteDestinoCorraleta.Activo == EstatusEnum.Inactivo)
                                            {
                                                var loteNuevo = new LoteInfo
                                                {
                                                    Activo               = EstatusEnum.Activo,
                                                    Cabezas              = 1,
                                                    CabezasInicio        = 1,
                                                    CorralID             = corralDestino.CorralID,
                                                    DisponibilidadManual = false,
                                                    OrganizacionID       = organizacion,
                                                    TipoCorralID         = corralDestino.TipoCorral.TipoCorralID,
                                                    TipoProcesoID        = TipoProceso.EngordaPropio.GetHashCode(),
                                                    UsuarioCreacionID    = usuarioCreacion
                                                };
                                                loteIDGuardar = loteBL.GuardaLote(loteNuevo);
                                            }
                                            else
                                            {
                                                loteIDGuardar = loteDestinoCorraleta.LoteID;
                                                loteDestinoCorraleta.Cabezas = loteDestinoCorraleta.Cabezas + 1;

                                                var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                                                {
                                                    LoteIDOrigen          = 0,
                                                    LoteIDDestino         = loteDestinoCorraleta.LoteID,
                                                    CabezasProcesadas     = 1,
                                                    UsuarioModificacionID = usuarioCreacion
                                                };
                                                loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                                                //loteBl.ActualizaNoCabezasEnLote(loteDestinoCorraleta, loteDestinoCorraleta);
                                            }

                                            if (ultimoMovimiento != null)
                                            {
                                                var animalMovimientoOrigen = new AnimalMovimientoInfo
                                                {
                                                    AnimalID          = animal.AnimalID,
                                                    CorralID          = corralDestino.CorralID,
                                                    LoteID            = loteIDGuardar,
                                                    TipoMovimientoID  = tipoMovimiento,
                                                    OrganizacionID    = organizacion,
                                                    OperadorID        = operador,
                                                    TrampaID          = ultimoMovimiento.TrampaID,
                                                    Peso              = ultimoMovimiento.Peso,
                                                    Temperatura       = ultimoMovimiento.Temperatura,
                                                    UsuarioCreacionID = usuarioCreacion
                                                };
                                                animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);


                                                loteOrigen.Cabezas = loteOrigen.Cabezas - 1;

                                                var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                                                {
                                                    LoteIDOrigen          = loteOrigen.LoteID,
                                                    LoteIDDestino         = 0,
                                                    CabezasProcesadas     = 1,
                                                    UsuarioModificacionID = usuarioCreacion
                                                };
                                                loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
                                            }
                                            else
                                            {
                                                retorno = -1;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        retorno = -1;
                                    }
                                }
                                else
                                {
                                    retorno = -1;
                                }
                            }
                            else
                            {
                                retorno = -1;
                            }
                        }
                        else//Salida por sacrificio
                        {
                            // Se crean los movimientos del animal
                            retorno = GuardarSalidaIndividialSacrificio(animal, organizacion, codigoCorral, corraletaID, usuarioCreacion, tipoMovimiento, operador);

                            // Se crea registro en animal Salida
                            retorno = salidaIndividualDAL.Guardar(arete, organizacion, codigoCorral,
                                                                  corraletaID, usuarioCreacion, tipoMovimiento);
                        }
                    }
                    else
                    {
                        retorno = -1;
                    }
                    transaccion.Complete();
                }

                return(retorno);
            }
            catch (ExcepcionGenerica)
            {
                retorno = -1;
                throw;
            }
            catch (Exception ex)
            {
                retorno = -1;
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #10
0
        /// <summary>
        /// Metodo para guardar la salida a sacrificio a un animal
        /// </summary>
        /// <param name="animal"></param>
        /// <param name="organizacion"></param>
        /// <param name="codigoCorral"></param>
        /// <param name="corraletaID"></param>
        /// <param name="usuarioCreacion"></param>
        /// <param name="tipoMovimiento"></param>
        /// <param name="operador"></param>
        private int GuardarSalidaIndividialSacrificio(AnimalInfo animal, int organizacion, string codigoCorral, int corraletaID, int usuarioCreacion, int tipoMovimiento, int operador)
        {
            int retorno            = 0;
            var animalBl           = new AnimalBL();
            var corralBl           = new CorralBL();
            var animalMovimientoBl = new AnimalMovimientoBL();
            var loteBl             = new LoteBL();

            var corralOrigen = corralBl.ObtenerCorralPorCodigo(organizacion, codigoCorral);

            if (corralOrigen != null)
            {
                var loteOrigen = loteBl.DeteccionObtenerPorCorral(organizacion, corralOrigen.CorralID);
                if (loteOrigen != null)
                {
                    var corralDestino = corralBl.ObtenerPorId(corraletaID);
                    if (corralDestino != null)
                    {
                        var loteDestino = loteBl.DeteccionObtenerPorCorral(organizacion, corralDestino.CorralID);
                        if (loteDestino == null)
                        {
                            // Si el corral destino no tiene lo te se crea uno
                            var loteBL        = new LoteBL();
                            int loteIDGuardar = 0;
                            var loteNuevo     = new LoteInfo
                            {
                                Activo               = EstatusEnum.Activo,
                                Cabezas              = 0,
                                CabezasInicio        = 0,
                                CorralID             = corralDestino.CorralID,
                                DisponibilidadManual = false,
                                OrganizacionID       = organizacion,
                                TipoCorralID         = corralDestino.TipoCorral.TipoCorralID,
                                TipoProcesoID        = TipoProceso.EngordaPropio.GetHashCode(),
                                UsuarioCreacionID    = usuarioCreacion
                            };
                            loteIDGuardar = loteBL.GuardaLote(loteNuevo);
                            loteDestino   = new LoteInfo {
                                LoteID = loteIDGuardar
                            };
                        }
                        // Se obtiene la info del ultimo movimiento del animal
                        var ultimoMovimiento = animalBl.ObtenerUltimoMovimientoAnimal(animal);
                        if (ultimoMovimiento != null)
                        {
                            var animalMovimientoOrigen = new AnimalMovimientoInfo
                            {
                                AnimalID          = animal.AnimalID,
                                CorralID          = corralDestino.CorralID,
                                LoteID            = loteDestino.LoteID,
                                TipoMovimientoID  = tipoMovimiento,
                                OperadorID        = operador,
                                OrganizacionID    = organizacion,
                                TrampaID          = ultimoMovimiento.TrampaID,
                                Peso              = ultimoMovimiento.Peso,
                                Temperatura       = ultimoMovimiento.Temperatura,
                                UsuarioCreacionID = usuarioCreacion
                            };
                            animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);

                            loteOrigen.Cabezas        = loteOrigen.Cabezas - 1;
                            loteDestino.Cabezas       = loteDestino.Cabezas + 1;
                            loteDestino.CabezasInicio = loteDestino.CabezasInicio + 1;

                            var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                            {
                                LoteIDOrigen          = loteOrigen.LoteID,
                                LoteIDDestino         = loteDestino.LoteID,
                                CabezasProcesadas     = 1,
                                UsuarioModificacionID = usuarioCreacion
                            };
                            loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                            //loteBl.ActualizaNoCabezasEnLote(loteDestino, loteOrigen);
                        }
                        else
                        {
                            retorno = -1;
                        }
                    }
                    else
                    {
                        retorno = -1;
                    }
                }
                else
                {
                    retorno = -1;
                }
            }
            else
            {
                retorno = -1;
            }

            return(retorno);
        }
예제 #11
0
        //Metodo que guarda el movimiento
        private void GuardarMovimientoTraspasoGanadoCorrales(List <AnimalInfo> aretesTotal, CorralInfo corralInfo, UsuarioInfo usuarioInfo)
        {
            //var animalInfo = new AnimalInfo();
            int loteOrigenID       = 0;
            int loteDestinoID      = 0;
            var loteBl             = new LoteBL();
            var animalBL           = new AnimalBL();
            var animalMovimientoBL = new AnimalMovimientoBL();
            var tipoProcesoBl      = new TipoProcesoBL();
            var fechaBL            = new FechaBL();
            var loteProyeccionBL   = new LoteProyeccionBL();

            List <AnimalMovimientoInfo> ultimosMovimientos = animalBL.ObtenerUltimoMovimientoAnimalXML(aretesTotal,
                                                                                                       usuarioInfo.
                                                                                                       Organizacion.
                                                                                                       OrganizacionID);

            if (ultimosMovimientos == null)
            {
                ultimosMovimientos = new List <AnimalMovimientoInfo>();
            }

            var resultadoLoteBl = loteBl.ObtenerLotesActivos(usuarioInfo.Organizacion.OrganizacionID,
                                                             Convert.ToInt32(corralInfo.CorralID));

            var tipoProcesoResult =
                tipoProcesoBl.ObtenerPorOrganizacion(usuarioInfo.Organizacion.OrganizacionID);

            var fechaServidor = fechaBL.ObtenerFechaActual();

            IList <LoteInfo> lotesCorrales = loteBl.ObtenerPorOrganizacionEstatus(
                usuarioInfo.Organizacion.OrganizacionID, EstatusEnum.Activo);

            if (lotesCorrales == null)
            {
                lotesCorrales = new List <LoteInfo>();
            }

            IList <LoteProyeccionInfo> lotesProyeccion =
                loteProyeccionBL.ObtenerPorLoteXML(usuarioInfo.Organizacion.OrganizacionID, lotesCorrales);


            var resultadoLote = -1;

            using (var transaction = new TransactionScope())
            {
                if (resultadoLoteBl == null)
                {
                    var loteCrear    = new LoteBL();
                    var loteInfoLote = new LoteInfo
                    {
                        Activo               = EstatusEnum.Activo,
                        Cabezas              = Convert.ToInt32(0),
                        CabezasInicio        = Convert.ToInt32(0),
                        CorralID             = corralInfo.CorralID,
                        DisponibilidadManual = false,
                        OrganizacionID       = usuarioInfo.Organizacion.OrganizacionID,
                        TipoCorralID         = corralInfo.TipoCorral.TipoCorralID,
                        TipoProcesoID        = tipoProcesoResult,
                        UsuarioCreacionID    = usuarioInfo.UsuarioID
                    };
                    resultadoLote = loteCrear.GuardaLote(loteInfoLote);
                    if ((corralInfo.TipoCorral != null &&
                         corralInfo.TipoCorral.TipoCorralID != TipoCorral.Enfermeria.GetHashCode()) ||
                        (corralInfo.TipoCorralId > 0 &&
                         corralInfo.TipoCorralId != TipoCorral.Enfermeria.GetHashCode()))
                    {
                        loteBl.ActualizaFechaCierre(resultadoLote, usuarioInfo.UsuarioID);
                    }
                }

                foreach (var animalInfo in aretesTotal)
                {
                    var animalMovimientoInfo = new AnimalMovimientoInfo();

                    animalInfo.OrganizacionIDEntrada = usuarioInfo.Organizacion.OrganizacionID;
                    //Obtener ultimo movimiento del animal
                    var ultimoMovimientoInfo =
                        ultimosMovimientos.FirstOrDefault(ani => ani.AnimalID == animalInfo.AnimalID);
                    if (ultimoMovimientoInfo != null)
                    {
                        animalMovimientoInfo.OrganizacionID = usuarioInfo.Organizacion.OrganizacionID;
                        animalMovimientoInfo.AnimalID       = animalInfo.AnimalID;

                        animalMovimientoInfo.CorralID = corralInfo.CorralID;
                        animalMovimientoInfo.LoteID   = resultadoLoteBl != null ? resultadoLoteBl.LoteID : resultadoLote;
                        DateTime diaHoy = fechaServidor.FechaActual.Date;
                        animalMovimientoInfo.FechaMovimiento   = diaHoy.Date;
                        animalMovimientoInfo.Peso              = ultimoMovimientoInfo.Peso;
                        animalMovimientoInfo.Temperatura       = ultimoMovimientoInfo.Temperatura;
                        animalMovimientoInfo.TipoMovimientoID  = (int)TipoMovimiento.TraspasoDeGanado;
                        animalMovimientoInfo.TrampaID          = ultimoMovimientoInfo.TrampaID;
                        animalMovimientoInfo.OperadorID        = ultimoMovimientoInfo.OperadorID;
                        animalMovimientoInfo.Observaciones     = String.Empty;
                        animalMovimientoInfo.Activo            = EstatusEnum.Activo;
                        animalMovimientoInfo.UsuarioCreacionID = usuarioInfo.UsuarioID;

                        //Se manda a guardar el registro en base de datos
                        animalMovimientoInfo = animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);
                        if (animalMovimientoInfo == null || animalMovimientoInfo.AnimalMovimientoID <= 0)
                        {
                            return;
                        }

                        var resultadoLoteOrigen  = loteBl.ObtenerPorID(ultimoMovimientoInfo.LoteID);
                        var resultadoLoteDestino = loteBl.ObtenerPorID(animalMovimientoInfo.LoteID);

                        if (resultadoLoteDestino != null)
                        {
                            resultadoLoteDestino.UsuarioModificacionID = usuarioInfo.UsuarioID;
                        }

                        //Incrementar y Decrementar cabezas
                        if (resultadoLoteOrigen != null && resultadoLoteDestino != null)
                        {
                            loteOrigenID  = resultadoLoteOrigen.LoteID;
                            loteDestinoID = resultadoLoteDestino.LoteID;

                            resultadoLoteDestino.Cabezas       = resultadoLoteDestino.Cabezas + 1;
                            resultadoLoteDestino.CabezasInicio = resultadoLoteDestino.CabezasInicio + 1;
                            resultadoLoteOrigen.Cabezas        = resultadoLoteOrigen.Cabezas - 1;

                            //Verificar si el Lote tiene cabezas en 0 para inactivarlo
                            resultadoLoteOrigen = loteBl.ObtenerPorID(ultimoMovimientoInfo.LoteID);
                            if (resultadoLoteOrigen.Cabezas != 0)
                            {
                                continue;
                            }
                        }
                    }
                }

                var loteOrigenInfo  = loteBl.ObtenerPorID(loteOrigenID);
                var loteDestinoInfo = loteBl.ObtenerPorID(loteDestinoID);

                if (lotesProyeccion != null && lotesProyeccion.Any())
                {
                    LoteProyeccionInfo proyeccionOrigen =
                        lotesProyeccion.FirstOrDefault(lote => lote.LoteID == loteOrigenInfo.LoteID);
                    LoteProyeccionInfo proyeccionDestino =
                        lotesProyeccion.FirstOrDefault(lote => lote.LoteID == loteDestinoInfo.LoteID);
                    if (proyeccionOrigen != null && proyeccionDestino == null)
                    {
                        proyeccionOrigen.LoteProyeccionID = 0;
                        int      diasEngordaOrigen = proyeccionOrigen.DiasEngorda;
                        DateTime fechaInicioLote   = loteOrigenInfo.FechaInicio;
                        int      diasEngordaReales =
                            new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days;

                        if ((diasEngordaOrigen - diasEngordaReales) <= 0)
                        {
                            proyeccionOrigen.DiasEngorda = 0;
                        }
                        else
                        {
                            proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales;
                        }

                        proyeccionOrigen.LoteID            = loteDestinoInfo.LoteID;
                        proyeccionOrigen.UsuarioCreacionID = usuarioInfo.UsuarioID;
                        loteProyeccionBL.Guardar(proyeccionOrigen);

                        var loteDAL = new LoteDAL();
                        var filtroDisponibilidad = new FiltroDisponilidadInfo
                        {
                            UsuarioId = usuarioInfo.UsuarioID,
                            ListaLoteDisponibilidad =
                                new List <DisponibilidadLoteInfo>
                            {
                                new DisponibilidadLoteInfo
                                {
                                    LoteId = loteDestinoInfo.LoteID,
                                    FechaDisponibilidad  = loteOrigenInfo.FechaDisponibilidad,
                                    DisponibilidadManual = loteOrigenInfo.DisponibilidadManual
                                }
                            }
                        };
                        loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad);
                    }
                }


                List <AnimalInfo> animalesOrigen =
                    animalBL.ObtenerAnimalesPorLote(usuarioInfo.Organizacion.OrganizacionID,
                                                    loteOrigenID);
                if (animalesOrigen != null && animalesOrigen.Any())
                {
                    loteOrigenInfo.Cabezas = animalesOrigen.Count;
                }

                List <AnimalInfo> animalesDestino =
                    animalBL.ObtenerAnimalesPorLote(usuarioInfo.Organizacion.OrganizacionID,
                                                    loteDestinoID);
                if (animalesDestino != null && animalesDestino.Any())
                {
                    loteDestinoInfo.Cabezas = animalesDestino.Count;
                }
                //Se actualizan las cabezas que tiene el lote
                var filtro = new FiltroActualizarCabezasLote
                {
                    CabezasProcesadas     = aretesTotal.Count,
                    LoteIDDestino         = loteDestinoInfo.LoteID,
                    LoteIDOrigen          = loteOrigenInfo.LoteID,
                    UsuarioModificacionID = usuarioInfo.UsuarioID
                };

                loteBl.ActualizarCabezasProcesadas(filtro);

                transaction.Complete();
            }
        }
예제 #12
0
        internal MemoryStream Guardar(MuertesEnTransitoInfo muerteEnTransito, List <AnimalInfo> animales)
        {
            MemoryStream retorno = null;

            try
            {
                Logger.Info();
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaMuerteEnTransito;
                var entradaGanadoMuerteLista = new List <EntradaGanadoMuerteInfo>();

                using (var transaction = new TransactionScope())
                {
                    var fecha             = DateTime.Now;
                    int organizacionID    = muerteEnTransito.OrganizacionID;
                    int usuarioCreacionID = muerteEnTransito.UsuarioCreacionID;
                    int pesoAnimal        = 0;
                    int corralID          = 0;
                    int loteID            = 0;

                    var datosInterface = false;
                    List <InterfaceSalidaAnimalInfo> interfaceSalidaAnimal = null;
                    var entradaGanadoBL             = new EntradaGanadoBL();
                    EntradaGanadoInfo entradaGanado = entradaGanadoBL.ObtenerPorID(muerteEnTransito.EntradaGanadoID);
                    if (entradaGanado != null)
                    {
                        loteID   = entradaGanado.LoteID;
                        corralID = entradaGanado.CorralID;
                        if (entradaGanado.FolioOrigen > 0)
                        {
                            var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
                            interfaceSalidaAnimal =
                                interfaceSalidaBL.ObtenerInterfazSalidaAnimal(entradaGanado.FolioOrigen,
                                                                              entradaGanado.OrganizacionOrigenID);
                            if (interfaceSalidaAnimal == null || interfaceSalidaAnimal.Count <= 0)
                            {
                                fecha      = entradaGanado.FechaEntrada;
                                pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
                                                             entradaGanado.CabezasRecibidas);
                            }
                            else
                            {
                                datosInterface = true;
                            }
                        }
                        else
                        {
                            pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
                                                         entradaGanado.CabezasRecibidas);
                        }
                    }
                    // Generamos el Folio

                    FolioBL folioBL     = new FolioBL();
                    var     folioMuerte = folioBL.ObtenerFolio(organizacionID, TipoFolio.MuertesEnTransito);

                    foreach (var animal in animales)
                    {
                        if (datosInterface)
                        {
                            pesoAnimal = interfaceSalidaAnimal.Where(
                                are => are.Arete.Equals(animal.Arete)).Select(
                                peso => Convert.ToInt32(peso.PesoCompra)).FirstOrDefault();
                        }

                        if (datosInterface)
                        {
                            fecha =
                                interfaceSalidaAnimal.Where(arete => arete.Arete.Equals(animal.Arete)).Select(
                                    fechaItz => fechaItz.FechaCompra).FirstOrDefault();
                        }

                        if (fecha == new DateTime(1, 1, 1))
                        {
                            fecha = DateTime.Now;
                        }

                        animal.OrganizacionIDEntrada = organizacionID;
                        animal.FolioEntrada          = muerteEnTransito.FolioEntrada;
                        animal.UsuarioCreacionID     = usuarioCreacionID;
                        animal.ClasificacionGanadoID = 1;
                        animal.CalidadGanadoID       = 1;
                        animal.TipoGanadoID          = 1;
                        animal.FechaCompra           = fecha;
                        animal.PesoCompra            = pesoAnimal;
                        animal.Activo = false;
                    }

                    //Guardamos los Animales
                    var animalBL = new AnimalBL();
                    animalBL.GuardarAnimal(animales);

                    //Obtenemos los animales almacenados con su
                    animales = animalBL.ObtenerPorArete(animales);

                    foreach (AnimalInfo animal in animales)
                    {
                        animal.UsuarioCreacionID = usuarioCreacionID;
                    }

                    //Genera los costos por animal
                    animales = animalBL.ProcesoGenerarCostos(animales);

                    foreach (AnimalInfo animal in animales)
                    {
                        var entradaGanadoMuerte = new EntradaGanadoMuerteInfo
                        {
                            EntradaGanado =
                                new EntradaGanadoInfo
                            {
                                EntradaGanadoID =
                                    muerteEnTransito.EntradaGanadoID,
                            },
                            Animal = new AnimalInfo {
                                Arete = animal.Arete
                            },
                            FolioMuerte       = folioMuerte,
                            Activo            = EstatusEnum.Activo,
                            UsuarioCreacionID = usuarioCreacionID,
                            Peso = animal.PesoCompra,
                            EntradaGanadMuerteDetalle = new List <EntradaGanadoMuerteDetalleInfo>(),
                            ProveedorFletes           = new ProveedorInfo()
                            {
                                CodigoSAP = muerteEnTransito.CodigoProveedor
                            },
                            Cliente = new ClienteInfo()
                            {
                                CodigoSAP = muerteEnTransito.Cliente.CodigoSAP, Descripcion = muerteEnTransito.Cliente.Descripcion
                            },
                            OrganizacionDestinoID = entradaGanado.OrganizacionID
                        };

                        if (animal.ListaCostosAnimal != null)
                        {
                            entradaGanadoMuerte.EntradaGanadMuerteDetalle =
                                animal.ListaCostosAnimal.Select(im => new EntradaGanadoMuerteDetalleInfo
                            {
                                Costo = new CostoInfo
                                {
                                    CostoID = im.CostoID
                                },
                                Importe             = im.Importe,
                                EntradaGanadoMuerte = entradaGanadoMuerte
                            }).ToList();
                        }
                        entradaGanadoMuerteLista.Add(entradaGanadoMuerte);
                    }

                    if (interfaceSalidaAnimal != null && interfaceSalidaAnimal.Count > 0 && animales != null && animales.Count > 0)
                    {
                        var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
                        foreach (AnimalInfo animal in animales)
                        {
                            InterfaceSalidaAnimalInfo interfaceSalidaAnimalIndividual = interfaceSalidaAnimal.FirstOrDefault(animalInfo => animalInfo.Arete.Equals(animal.Arete));
                            interfaceSalidaBL.GuardarAnimalID(interfaceSalidaAnimalIndividual, animal.AnimalID);
                        }
                    }

                    //Asignamos el AnimalID en la lista de muertes ante sde guardar.
                    foreach (EntradaGanadoMuerteInfo muerte in entradaGanadoMuerteLista)
                    {
                        muerte.Animal.AnimalID = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
                                                 .Select(animal => animal.AnimalID).FirstOrDefault();
                        muerte.Peso = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
                                      .Select(animal => animal.PesoCompra).FirstOrDefault();
                    }
                    //Guardamos las muertes en transito
                    var muertesEnTransitoDal = new MuertesEnTransitoDAL();
                    muertesEnTransitoDal.Guardar(entradaGanadoMuerteLista, muerteEnTransito.Cliente);


                    //Creamos los movimientos para el animal
                    if (animales != null && animales.Any())
                    {
                        fecha = DateTime.Now;
                        var animalMovimientoBL = new AnimalMovimientoBL();
                        List <AnimalMovimientoInfo> movimientosAnimal = animales.Select(ani =>
                                                                                        new AnimalMovimientoInfo
                        {
                            AnimalID          = ani.AnimalID,
                            Activo            = EstatusEnum.Activo,
                            CorralID          = corralID,
                            LoteID            = loteID,
                            FechaMovimiento   = fecha,
                            OrganizacionID    = organizacionID,
                            TipoMovimientoID  = TipoMovimiento.MuerteTransito.GetHashCode(),
                            OperadorID        = 1,
                            TrampaID          = 1,
                            Peso              = ani.PesoCompra,
                            UsuarioCreacionID = usuarioCreacionID,
                        }).ToList();
                        animalMovimientoBL.GuardarAnimalMovimientoXML(movimientosAnimal);
                    }
                    //Afectamos el lote correspondiente.
                    var loteBl   = new LoteBL();
                    var loteInfo = loteBl.ObtenerPorID(muerteEnTransito.LoteID);
                    loteInfo.UsuarioModificacionID = muerteEnTransito.UsuarioCreacionID;
                    loteInfo.Cabezas -= muerteEnTransito.MuertesTransito;

                    var filtro = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = muerteEnTransito.MuertesTransito,
                        LoteIDDestino         = 0,
                        LoteIDOrigen          = loteInfo.LoteID,
                        UsuarioModificacionID = usuarioCreacionID
                    };

                    var cabezasActualizadas = loteBl.ActualizarCabezasProcesadas(filtro);

                    //Executamos el SP CorteGanado_CierrePartidaPesoOrigenLLegada(Antes-->CorteGanado_PesoCompraDirecta), si se inactiva el lote.
                    if (cabezasActualizadas.CabezasOrigen <= 0)
                    {
                        //muertesEnTransitoDal.CorteGanado_PesoCompraDirecta(muerteEnTransito.OrganizacionID, muerteEnTransito.CorralID, muerteEnTransito.LoteID);
                        var corteGanadoBl = new CorteGanadoBL();
                        corteGanadoBl.ObtenerPesosOrigenLlegada(muerteEnTransito.OrganizacionID,
                                                                muerteEnTransito.CorralID,
                                                                muerteEnTransito.LoteID);
                    }

                    #region Poliza
                    //VentaGanadoBL ventaGanadoBL = new VentaGanadoBL();
                    //List<EntradaGanadoMuerteInfo> ventasGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(folio, organizacionID);
                    //if (ventasGanado != null && ventasGanado.Any())

                    if (entradaGanadoMuerteLista != null && entradaGanadoMuerteLista.Any())
                    {
                        poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PolizaMuerteTransito);
                        polizaMuerteEnTransito = poliza.GeneraPoliza(entradaGanadoMuerteLista);
                        if (polizaMuerteEnTransito != null && polizaMuerteEnTransito.Any())
                        {
                            polizaMuerteEnTransito.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = organizacionID;
                                org.UsuarioCreacionID      = usuarioCreacionID;
                                org.ArchivoEnviadoServidor = 1;
                            });

                            entradaGanadoMuerteLista.ToList().ForEach(org =>
                            {
                                org.EntradaGanado.Lote         = entradaGanado.Lote;
                                org.EntradaGanado.CodigoCorral = entradaGanado.CodigoCorral;
                            });
                            retorno = poliza.ImprimePoliza(entradaGanadoMuerteLista, polizaMuerteEnTransito);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaMuerteEnTransito, TipoPoliza.PolizaMuerteTransito);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaMuertesEnTransito(folioMuerte, organizacionID);

                    #endregion Poliza

                    animalBL.EnviarAHistorico(animales);

                    transaction.Complete();
                }
                return(retorno);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
예제 #13
0
        /// <summary>
        /// Guardar entrada enfermeria
        /// </summary>
        internal EntradaGanadoEnfermeriaInfo GuardarEntradaEnfermeria(EntradaGanadoEnfermeriaInfo entradaGanadoEnfermeria)
        {
            entradaGanadoEnfermeria.Resultado = false;
            try
            {
                var resultadoCabezas  = new CabezasActualizadasInfo();
                var transactionOption = new TransactionOptions();
                transactionOption.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
                using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption))
                {
                    var animalDal          = new AnimalDAL();
                    var animalMovimientoBL = new AnimalMovimientoBL();
                    var corralBL           = new CorralBL();
                    var loteBL             = new LoteBL();

                    bool actualizaAreteDeteccion = entradaGanadoEnfermeria.Deteccion.ActualizarAreteDeteccion;
                    bool animalRecaido           = entradaGanadoEnfermeria.AnimalRecaido;

                    if (entradaGanadoEnfermeria.CambiarTipoGanado &&
                        entradaGanadoEnfermeria.Deteccion.Animal.AnimalID > 0 &&
                        entradaGanadoEnfermeria.Deteccion.Animal.TipoGanadoID != entradaGanadoEnfermeria.Animal.TipoGanadoID)
                    {
                        entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
                        entradaGanadoEnfermeria.Animal.UsuarioModificacionID = entradaGanadoEnfermeria.UsuarioId;
                    }
                    if (entradaGanadoEnfermeria.Animal.AnimalID == 0)
                    {
                        entradaGanadoEnfermeria.Animal.AnimalID       = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
                        entradaGanadoEnfermeria.Animal.AplicaBitacora = entradaGanadoEnfermeria.Deteccion.Animal.AplicaBitacora;
                    }
                    AnimalInfo animalInfo = animalDal.GuardarAnimal(entradaGanadoEnfermeria.Animal);
                    if (actualizaAreteDeteccion)
                    {
                        //Si el flag esta activo se actualiza el arete en la deteccion de ganado cuando solo traen fotos
                        var deteccionBl = new DeteccionBL();
                        deteccionBl.ActualizarDeteccionConFoto(entradaGanadoEnfermeria.Deteccion);
                    }
                    /* Si esta activo el flag de recaido generar la deteccion */
                    if (animalRecaido)
                    {
                        entradaGanadoEnfermeria.Deteccion.DeteccionID = GenerarDeteccionAnimalGenerica(entradaGanadoEnfermeria);
                    }

                    if (animalInfo != null && animalInfo.AnimalID > 0)
                    {
                        entradaGanadoEnfermeria.Animal = animalInfo;
                        entradaGanadoEnfermeria.Movimiento.AnimalID = animalInfo.AnimalID;
                        if (entradaGanadoEnfermeria.LoteDestino.LoteID == 0)
                        {
                            entradaGanadoEnfermeria.LoteDestino.LoteID = loteBL.GuardaLote(entradaGanadoEnfermeria.LoteDestino);
                            entradaGanadoEnfermeria.Movimiento.LoteID  = entradaGanadoEnfermeria.LoteDestino.LoteID;
                        }
                        //Se almacena el movimiento
                        AnimalMovimientoInfo animalMovimientoInfo =
                            animalMovimientoBL.GuardarAnimalMovimiento(entradaGanadoEnfermeria.Movimiento);
                        if (animalMovimientoInfo != null && animalMovimientoInfo.AnimalMovimientoID > 0)
                        {
                            if (entradaGanadoEnfermeria.Tratamientos.Any(registro => registro.Seleccionado))
                            {
                                var almacenpl = new AlmacenBL();
                                entradaGanadoEnfermeria.AlmacenMovimiento.AnimalMovimientoID =
                                    animalMovimientoInfo.AnimalMovimientoID;
                                entradaGanadoEnfermeria.AlmacenMovimiento.AnimalID = animalInfo.AnimalID;
                                almacenpl.GuardarDescontarTratamientos(entradaGanadoEnfermeria.Tratamientos,
                                                                       entradaGanadoEnfermeria.AlmacenMovimiento);
                            }
                            entradaGanadoEnfermeria.Deteccion.AnimalMovimiento = animalMovimientoInfo;
                            GurdarDeteccion(entradaGanadoEnfermeria.Deteccion, entradaGanadoEnfermeria.ListaProblemas);

                            /* Se desactiva la deteccion */
                            var deteccion = new DeteccionInfo
                            {
                                DeteccionID       = entradaGanadoEnfermeria.Deteccion.DeteccionID,
                                UsuarioCreacionID = entradaGanadoEnfermeria.UsuarioId,
                                Arete             = entradaGanadoEnfermeria.Animal.Arete
                            };
                            EliminarDeteccion(deteccion);
                            #region LOTE
                            //Se decrementan las cabezas del lote
                            if (entradaGanadoEnfermeria.LoteDestino.LoteID != entradaGanadoEnfermeria.LoteOrigen.LoteID)
                            {
                                entradaGanadoEnfermeria.LoteDestino = loteBL.ObtenerPorID(entradaGanadoEnfermeria.LoteDestino.LoteID);
                                var animalBL = new AnimalBL();
                                List <AnimalInfo> animalesDestino =
                                    animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
                                                                    entradaGanadoEnfermeria.LoteDestino.LoteID);
                                if (animalesDestino != null && animalesDestino.Any())
                                {
                                    entradaGanadoEnfermeria.LoteDestino.Cabezas = animalesDestino.Count;
                                }
                                //Una vez insertado el lote y el animal se incrementan las cabezas de lote
                                entradaGanadoEnfermeria.LoteDestino.Cabezas =
                                    entradaGanadoEnfermeria.LoteDestino.Cabezas + 1;
                                if (entradaGanadoEnfermeria.LoteDestino.Cabezas > entradaGanadoEnfermeria.LoteDestino.CabezasInicio)
                                {
                                    entradaGanadoEnfermeria.LoteDestino.CabezasInicio =
                                        entradaGanadoEnfermeria.LoteDestino.CabezasInicio + 1;
                                }
                                entradaGanadoEnfermeria.LoteDestino.UsuarioModificacionID =
                                    entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID;
                                // ------ //
                                entradaGanadoEnfermeria.LoteOrigen.Cabezas =
                                    entradaGanadoEnfermeria.LoteOrigen.Cabezas - 1;

                                List <AnimalInfo> animales =
                                    animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
                                                                    entradaGanadoEnfermeria.LoteOrigen.LoteID);
                                if (animales != null && animales.Any())
                                {
                                    entradaGanadoEnfermeria.LoteOrigen.Cabezas = animales.Count;
                                }
                                //Se actualizan las cabezas que tiene el lote
                                var filtro = new FiltroActualizarCabezasLote
                                {
                                    CabezasProcesadas     = 1,
                                    LoteIDDestino         = entradaGanadoEnfermeria.LoteDestino.LoteID,
                                    LoteIDOrigen          = entradaGanadoEnfermeria.LoteOrigen.LoteID,
                                    UsuarioModificacionID = entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID
                                };

                                resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);
                            }
                            #endregion LOTE
                            //Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
                            if (resultadoCabezas.CabezasOrigen <= 0)
                            {
                                //Se obtiene el Corral para ver Si es de Recepcion
                                CorralInfo corralInfo = corralBL.ObtenerCorralPorCodigo(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
                                                                                        entradaGanadoEnfermeria.LoteOrigen.Corral.Codigo);
                                if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
                                {
                                    /* Si el corral es de Recepcion */
                                    var corteGanadoPl = new CorteGanadoBL();
                                    corteGanadoPl.ObtenerPesosOrigenLlegada(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
                                                                            entradaGanadoEnfermeria.LoteOrigen.CorralID,
                                                                            entradaGanadoEnfermeria.LoteOrigen.LoteID);
                                }
                            }
                            transaction.Complete();
                            entradaGanadoEnfermeria.Resultado = true;
                        }
                    }
                }
            }
            catch (ExcepcionGenerica ex)
            {
                Logger.Error(ex);
                entradaGanadoEnfermeria.Resultado = false;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                entradaGanadoEnfermeria.Resultado = false;
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoEnfermeria);
        }
        /// <summary>
        /// Guardar la salida por recuperacion
        /// </summary>
        /// <returns></returns>
        private bool GuardarSalidaRecuperacion()
        {
            var regreso = false;

            if (lisBoxCorralDestino.Items.Count > 0)
            {
                var lotePL = new LotePL();
                var lote   = new LoteInfo
                {
                    Corral = new CorralInfo
                    {
                        CorralID = corralIdOrigen
                    },
                    CorralID       = corralIdOrigen,
                    OrganizacionID = organizacionId
                };
                lote = lotePL.ObtenerPorCorralID(lote);
                var animalMovimientoPL = new AnimalMovimientoPL();
                List <AnimalMovimientoInfo> movimientosAnimal = animalMovimientoPL.ObtenerUltimoMovimientoAnimal(animales);
                if (movimientosAnimal != null)
                {
                    var loteDestino = new LoteInfo
                    {
                        Corral = new CorralInfo
                        {
                            CorralID = corralIdDestino
                        },
                        CorralID       = corralIdDestino,
                        OrganizacionID = organizacionId
                    };
                    loteDestino = lotePL.ObtenerPorCorralID(loteDestino);
                    movimientosAnimal.ForEach(datos =>
                    {
                        datos.LoteID           = loteDestino.LoteID;
                        datos.CorralID         = corralIdDestino;
                        datos.TipoMovimientoID =
                            TipoMovimiento.SalidaEnfermeria.GetHashCode();
                        datos.Activo                = EstatusEnum.Activo;
                        datos.UsuarioCreacionID     = usuario;
                        datos.UsuarioModificacionID = usuario;
                    });
                    lote.Cabezas        -= movimientosAnimal.Count;
                    loteDestino.Cabezas += movimientosAnimal.Count;
                    using (var scope = new TransactionScope())
                    {
                        animalMovimientoPL.GuardarAnimalMovimientoXML(movimientosAnimal);
                        var filtro = new FiltroActualizarCabezasLote
                        {
                            CabezasProcesadas     = movimientosAnimal.Count,
                            LoteIDDestino         = loteDestino.LoteID,
                            LoteIDOrigen          = lote.LoteID,
                            UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado()
                        };

                        lotePL.ActualizarCabezasProcesadas(filtro);
                        scope.Complete();
                    }
                    regreso = true;
                }
            }
            return(regreso);
        }