Esempio n. 1
0
    public static void Sort(int[] lista)
    {
        // Variables de estado
        int maxDigitos = Conteo.MaxDigitos(lista), digitoActual;

        int[]  ordenada = new int[lista.Length];
        Conteo conteo   = new Conteo();

        for (int dig = 1, len = lista.Length; dig <= maxDigitos; dig++)
        {
            // Recorrer de izquierda a derecha
            for (int i = 0; i < len; i++)
            {
                digitoActual = Conteo.Digito(lista[i], dig);
                conteo.arr[digitoActual]++;
            }

            conteo.Acumular();

            // Recorrer de derecha a izquierda
            for (int i = len - 1; i >= 0; i--)
            {
                digitoActual = Conteo.Digito(lista[i], dig);
                ordenada[--conteo.arr[digitoActual]] = lista[i];
            }

            conteo.Resetear();
            Array.Copy(ordenada, lista, len);
        }
    }
Esempio n. 2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Ejercicio del curso!");


            Console.WriteLine("Ejercicio de Andony: ");
            var suma = new SumaNumeros();

            Console.WriteLine(suma.Sum(1, 2));
            Prueba.Respuesta("hola");


            Console.WriteLine("Ejercicio de Gonzalo: ");
            var area = new areaTriandulo();

            Console.WriteLine(area.triArea(12, 32));

            Console.WriteLine("Ejercicio de Jeremy: ");
            var contarNum = new Conteo();

            contarNum.Contar();

            Console.WriteLine("Ejercicio de Kevin: ");
            Console.WriteLine(AgeToDays.CalcEdad(15));

            Console.WriteLine("Ejercicio de Kimberly: ");
            var multi = new MultiplicacionNumeros();

            Console.WriteLine(multi.Mult(5, 7));
            Console.WriteLine("Ejercicio de Reymond");
            var resultado = new Convertir();

            Console.WriteLine(resultado.convert(4));
        }
Esempio n. 3
0
    public static int Digito(int num, int digitNum, int digito = 0)
    {
        if (digitNum == 0)
        {
            return(digito);
        }

        return(Conteo.Digito(num / 10, digitNum - 1, num % 10));
    }
Esempio n. 4
0
    // Funciones de ayuda para el manejo de dígitos
    public static int Digitos(int num, int digitos = 1)
    {
        if ((num / 10) == 0)
        {
            return(digitos);
        }

        return(Conteo.Digitos(num / 10, digitos + 1));
    }
Esempio n. 5
0
        public OrdenBuilder(DateTime _fecha, string _razon)
        {
            _orden = new Orden();
            _orden.FechaPlanificacion = _fecha;
            _orden.Razon = _razon;

            Conteo _conteo = new Conteo();

            _conteo.ResultadoConteo = null;
            ICollection <Conteo> _conteos = new List <Conteo>();

            _conteos.Add(_conteo);
            _orden.Conteo = _conteos;
        }
Esempio n. 6
0
    public static int MaxDigitos(int[] numeros)
    {
        int maxDig = 0;

        for (int i = 0, len = numeros.Length; i < len; i++)
        {
            int digitosActual = Conteo.Digitos(numeros[i]);
            if (digitosActual > maxDig)
            {
                maxDig = digitosActual;
            }
        }

        return(maxDig);
    }
Esempio n. 7
0
        public ConteoFisicoPage(ContextoDatos contexto, Articulo articulo)
        {
            Contexto = contexto;

            InitializeComponent();

            this.articulo = articulo;
            //Cargar campos importantes del artículo
            lblIdArt.Text   = articulo.id_articulo;
            lblDescArt.Text = articulo.descripcion_articulo;
            //Cargar fuente de datos al listview de conteos
            listaConteo.ItemsSource = Contexto.GetConteos(articulo.id_articulo);

            //Botón nuevo conteo
            btnNuevoConteo.Clicked += async(sender, events) =>
            {
                if (string.IsNullOrEmpty(txtCantidad.Text))
                {
                    //Validar cantidad
                    await DisplayAlert("Cantidad", "Ingrese una cantidad", "Aceptar");

                    return;
                }

                //Validar que la cantidad sea numérica
                if (!int.TryParse(txtCantidad.Text, out cantidad))
                {
                    await DisplayAlert("Cantidad", "La cantidad debe ser un entero", "Aceptar");

                    return;
                }

                //Nueva instancia de conteo
                conteo = new Conteo();

                //Seteo nuevo conteo
                conteo.id_inventario = articulo.id_inventario;
                conteo.id_articulo   = articulo.id_articulo;
                conteo.id_usuario    = VariablesGlobales.idusuario;
                conteo.conteo        = Convert.ToInt32(txtCantidad.Text);
                conteo.nota          = string.IsNullOrEmpty(txtNota.Text) ? "" : txtNota.Text;
                conteo.fecha         = DateTime.Now;

                //Guardar el conteo
                Contexto.Guardar(new[] { conteo });

                //Cargar nueva lista de conteo del artículo
                listaConteo.ItemsSource = Contexto.GetConteos(articulo.id_articulo);

                //Limpiar campo
                txtCantidad.Text = string.Empty;
                txtNota.Text     = string.Empty;

                //Proceso correcto
                await DisplayAlert("Correcto", "Se ha guardado el nuevo conteo", "Aceptar");
            };

            btnModificarConteo.Clicked += async(s, e) =>
            {
                //Validar que la cantidad no esté vacía
                if (string.IsNullOrEmpty(txtCantidad.Text))
                {
                    await DisplayAlert("Cantidad", "Ingrese una cantidad", "Aceptar");

                    return;
                }

                //Validar que se halla selecciona un conteo
                if (conteo == null)
                {
                    await DisplayAlert("Seleccione", "Debe seleccionar el conteo a modificar", "Aceptar");

                    return;
                }

                //Validar que el conteo sea numérico
                if (!int.TryParse(txtCantidad.Text, out cantidad))
                {
                    await DisplayAlert("Cantidad", "La cantidad debe ser un entero", "Aceptar");

                    return;
                }

                //Setear canmpos variables en la modificación
                conteo.conteo = int.Parse(txtCantidad.Text);
                conteo.nota   = txtNota.Text;
                conteo.fecha  = DateTime.Now;

                //Actualizar conteo
                Contexto.Actualizar(new[] { conteo });

                //Refrescar lista
                listaConteo.ItemsSource = Contexto.GetConteos(articulo.id_articulo);

                //Limpiar campos
                txtCantidad.Text = string.Empty;
                txtNota.Text     = string.Empty;

                //Proceso correcto
                await DisplayAlert("Correcto", "Se ha actualizado el conteo", "Aceptar");
            };

            btnEliminarConteo.Clicked += async(s, e) =>
            {
                //Validar que el campo cantidad no vaya vacio
                if (string.IsNullOrEmpty(txtCantidad.Text))
                {
                    await DisplayAlert("Cantidad", "Ingrese una cantidad", "Aceptar");

                    return;
                }

                //Validar que se halla seleccionado un conteo
                if (conteo == null)
                {
                    await DisplayAlert("Seleccione", "Debe seleccionar el conteo a eliminar", "Aceptar");

                    return;
                }

                //Validar que la cantidad sea entera
                if (!int.TryParse(txtCantidad.Text, out cantidad))
                {
                    await DisplayAlert("Cantidad", "La cantidad debe ser un entero", "Aceptar");

                    return;
                }

                //Borrar conteo
                Contexto.Borrar(new[] { conteo });

                //Refrescar lista
                listaConteo.ItemsSource = Contexto.GetConteos(articulo.id_articulo);

                //Limpiar campos
                txtCantidad.Text = string.Empty;
                txtNota.Text     = string.Empty;

                //Proceso correcto
                await DisplayAlert("Correcto", "Se ha eliminado el conteo", "Aceptar");
            };

            //Seleccionar una registro de la lista
            listaConteo.ItemSelected += (s, e) =>
            {
                conteo = (Conteo)e.SelectedItem;

                txtCantidad.Text = conteo.conteo.ToString();
                txtNota.Text     = conteo.nota;
            };
        }
Esempio n. 8
0
        public async Task <IActionResult> Create([Bind("IdOrden,FechaPlanificacion,Razon,Estado")] Orden orden)
        {
            var hayPesaje     = (Request.Form["hayPesaje"] == "on");
            var hayInspeccion = (Request.Form["hayInspeccion"] == "on");
            var hayVacunacion = (Request.Form["hayVacunacion"] == "on");


            Abstracciones.OrdenBuilder builder = new Abstracciones.OrdenBuilder(orden.FechaPlanificacion, orden.Razon);
            var seleccionados = (Request.Form["PlanificacionVacunacion"].ToList());

            //Pesaje
            if (hayPesaje)
            {
                builder.WithPesaje(true);
            }
            else
            {
                builder.WithPesaje(false);
            }

            //Inspeccion
            if (hayInspeccion)
            {
                builder.WithInspeccion(true);
            }
            else
            {
                builder.WithInspeccion(false);
            }

            //Vacunacion
            if (hayVacunacion)
            {
                builder.WithVacunacion(true, seleccionados);
            }
            else
            {
                builder.WithVacunacion(false, null);
            }

            orden = builder.GetOrden();
            if (ModelState.IsValid)
            {
                using (var transaccion = _context.Database.BeginTransaction())
                {
                    try
                    {
                        if (orden.FechaPlanificacion < DateTime.Now)
                        {
                            return(View("~/Views/Shared/Error.cshtml"));
                        }
                        _context.Add(orden);
                        await _context.SaveChangesAsync();



                        orden.Conteo.First().IdOrden = orden.IdOrden;
                        Conteo cont = orden.Conteo.First();
                        _context.Add(cont);

                        if (orden.Vacunacion != null)
                        {
                            orden.Vacunacion.First().IdOrden = orden.IdOrden;
                            _context.Add(orden.Vacunacion.First());
                            foreach (PlanificacionVacunacion plan in orden.Vacunacion.First().PlanificacionVacunacion)
                            {
                                plan.IdVacuna = orden.Vacunacion.First().IdVacunacion;
                                _context.Add(plan);
                            }
                        }
                        if (orden.Inspeccion != null)
                        {
                            orden.Inspeccion.First().IdOrden = orden.IdOrden;
                            _context.Add(orden.Inspeccion.First());
                        }
                        if (orden.Pesaje != null)
                        {
                            orden.Pesaje.First().IdOrden = orden.IdOrden;
                            _context.Add(orden.Pesaje.First());
                        }
                        transaccion.Commit();
                    }
                    catch
                    {
                        transaccion.Rollback();
                        return(View("~/Views/Shared/Error.cshtml"));

                        throw;
                    }
                    return(RedirectToAction(nameof(Index)));
                }
            }
            return(View(orden));
        }
Esempio n. 9
0
        public async Task <IActionResult> Finalizar(int?id, [Bind("Tag,asistencia,vacunado,peso,padecimientos,glosa")] List <FormResultado> results)
        {
            Orden orden = _context.Orden.Where(x => x.IdOrden == id).First();

            if (ModelState.IsValid)
            {
                using (var transaccion = _context.Database.BeginTransaction())
                {
                    try
                    {
                        var queryPes  = _context.Pesaje.Where(x => x.IdOrden == orden.IdOrden);
                        var queryVac  = _context.Vacunacion.Where(x => x.IdOrden == orden.IdOrden);
                        var queryInsp = _context.Inspeccion.Where(x => x.IdOrden == orden.IdOrden);
                        var queryCont = _context.Conteo.Where(x => x.IdOrden == orden.IdOrden);

                        Pesaje     pes  = null;
                        Vacunacion vac  = null;
                        Inspeccion insp = null;
                        Conteo     cont = null;

                        if (queryPes.Count() != 0)
                        {
                            pes = queryPes.First();
                        }
                        if (queryVac.Count() != 0)
                        {
                            vac = queryVac.First();
                        }
                        if (queryInsp.Count() != 0)
                        {
                            insp = queryInsp.First();
                        }
                        if (queryCont.Count() != 0)
                        {
                            cont = queryCont.First();
                        }

                        foreach (FormResultado r in results)
                        {
                            Ganado vaca = _context.Ganado.Where(x => x.Tag == r.Tag).First();
                            if (pes != null)
                            {
                                orden.Pesaje.Add(pes);
                            }
                            if (vac != null)
                            {
                                orden.Vacunacion.Add(vac);
                            }
                            if (insp != null)
                            {
                                orden.Inspeccion.Add(insp);
                            }
                            if (cont != null)
                            {
                                orden.Conteo.Add(cont);
                            }

                            ResultadoConteo     resultCont = new ResultadoConteo();
                            ResultadoPesaje     resultPes  = new ResultadoPesaje();
                            ResultadoVacunacion resultVac  = new ResultadoVacunacion();
                            ResultadoInspeccion resultInsp = new ResultadoInspeccion();

                            // Encargandose del conteo;
                            resultCont.Asistencia = r.asistencia;
                            resultCont.IdGanado   = vaca.IdGanado;
                            resultCont.IdConteo   = orden.Conteo.First().IdConteo;
                            _context.Add(resultCont);

                            //Encargandose del Pesaje
                            if (resultCont.Asistencia == 1 && orden.Pesaje.Count() > 0)
                            {
                                resultPes.Peso     = r.peso;
                                resultPes.IdGanado = vaca.IdGanado;
                                resultPes.IdPesaje = orden.Pesaje.First().IdPesaje;
                                _context.Add(resultPes);
                            }

                            //Encargandose de la Vacunacion
                            if (resultCont.Asistencia == 1 && orden.Vacunacion.Count() > 0)
                            {
                                List <VacunaAplicada> aplicaciones = new List <VacunaAplicada>();
                                var queryPlanificacion             = _context.PlanificacionVacunacion.Where(x => x.IdVacunacion == orden.Vacunacion.First().IdVacunacion);
                                foreach (PlanificacionVacunacion plan in queryPlanificacion)
                                {
                                    VacunaAplicada aplicacion = new VacunaAplicada();
                                    aplicacion.IdVacuna = plan.IdVacuna;
                                    aplicaciones.Add(aplicacion);
                                }
                                orden.Vacunacion.First().PlanificacionVacunacion = queryPlanificacion.ToList();
                                resultVac.IdGanado     = vaca.IdGanado;
                                resultVac.IdVacunacion = orden.Vacunacion.First().IdVacunacion;
                                _context.Add(resultVac);
                                foreach (VacunaAplicada ap in aplicaciones)
                                {
                                    ap.IdResultadoVacunacion = resultVac.IdResultadoVacunacion;
                                    _context.Add(ap);
                                }
                            }

                            //Encargandose de la Inspeccion
                            if (resultCont.Asistencia == 1 && orden.Inspeccion.Count() > 0)
                            {
                                List <InspeccionPadecimiento> inspad_list = new List <InspeccionPadecimiento>();
                                resultInsp.Glosa        = r.glosa;
                                resultInsp.IdGanado     = vaca.IdGanado;
                                resultInsp.IdInspeccion = orden.Inspeccion.First().IdInspeccion;
                                foreach (int num in r.padecimientos)
                                {
                                    InspeccionPadecimiento inspad = new InspeccionPadecimiento();
                                    inspad.IdPadecimiento = num;
                                    inspad_list.Add(inspad);
                                }
                                resultInsp.InspeccionPadecimiento = inspad_list;
                                _context.Add(resultInsp);
                                foreach (InspeccionPadecimiento ip in inspad_list)
                                {
                                    ip.IdResultadoInspeccion = resultInsp.IdResultadoInspeccion;
                                    _context.Add(ip);
                                }
                                //orden.Estado='desactivado'
                                _context.Update(orden);
                            }
                        }


                        transaccion.Commit();
                    }
                    catch
                    {
                        transaccion.Rollback();
                        return(View("~/Views/Shared/Error.cshtml"));

                        throw;
                    }
                    await _context.SaveChangesAsync();
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(orden));
        }
Esempio n. 10
0
        public async Task <IActionResult> Edit(int id, [Bind("IdOrden,FechaPlanificacion,Razon,Estado")] Orden orden)
        {
            var hayPesaje     = (Request.Form["hayPesaje"] == "on");
            var hayInspeccion = (Request.Form["hayInspeccion"] == "on");
            var hayVacunacion = (Request.Form["hayVacunacion"] == "on");
            var seleccionados = (Request.Form["PlanificacionVacunacion"].ToList());

            if (id != orden.IdOrden)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    if (orden.FechaPlanificacion < DateTime.Now)
                    {
                        return(View("~/Views/Shared/Error.cshtml"));
                    }
                    Pesaje     psj;
                    Vacunacion vcn;
                    Inspeccion nspccn;
                    Conteo     cnt = _context.Conteo.Where(o => o.IdOrden == orden.IdOrden).First();

                    if (_context.Pesaje.Where(o => o.IdOrden == orden.IdOrden).Count() == 0)
                    {
                        psj = null;
                    }
                    else
                    {
                        psj = _context.Pesaje.Where(o => o.IdOrden == orden.IdOrden).First();
                    }

                    if (_context.Vacunacion.Where(o => o.IdOrden == orden.IdOrden).Count() == 0)
                    {
                        vcn = null;
                    }
                    else
                    {
                        vcn = _context.Vacunacion.Where(o => o.IdOrden == orden.IdOrden).First();
                    }

                    if (_context.Inspeccion.Where(o => o.IdOrden == orden.IdOrden).Count() == 0)
                    {
                        nspccn = null;
                    }
                    else
                    {
                        nspccn = _context.Inspeccion.Where(o => o.IdOrden == orden.IdOrden).First();
                    }



                    Abstracciones.OrdenBuilder builder = new Abstracciones.OrdenBuilder(orden);

                    if (hayPesaje)
                    {
                        builder.WithPesaje(true);
                    }
                    else
                    {
                        if (psj != null)
                        {
                            _context.Remove(psj);
                        }
                        builder.WithPesaje(false);
                    }

                    if (hayInspeccion)
                    {
                        builder.WithInspeccion(true);
                    }
                    else
                    {
                        if (nspccn != null)
                        {
                            _context.Remove(nspccn);
                        }
                        builder.WithInspeccion(false);
                    }

                    if (hayVacunacion)
                    {
                        builder.WithVacunacion(true, seleccionados);
                    }
                    else
                    {
                        builder.WithVacunacion(false, null);
                    }



                    if (vcn != null)
                    {
                        foreach (PlanificacionVacunacion plan in _context.PlanificacionVacunacion.Where(o => o.IdVacunacion == vcn.IdVacunacion))
                        {
                            _context.Remove(plan);
                        }
                        _context.Remove(vcn);
                    }


                    orden = builder.GetOrden();
                    using (var transaccion = _context.Database.BeginTransaction())
                    {
                        try
                        {
                            _context.Update(orden);
                            await _context.SaveChangesAsync();

                            cnt.IdOrden = orden.IdOrden;
                            Conteo cont = cnt;
                            _context.Update(cont);

                            if (orden.Inspeccion != null && orden.Inspeccion.Count() != 0)
                            {
                                orden.Inspeccion.First().IdOrden = orden.IdOrden;
                                if (nspccn == null)
                                {
                                }
                                else
                                {
                                    orden.Inspeccion.First().IdInspeccion = nspccn.IdInspeccion;
                                    _context.Update(orden.Inspeccion.First());
                                }
                            }
                            if (orden.Pesaje != null && orden.Pesaje.Count() != 0)
                            {
                                orden.Pesaje.First().IdOrden = orden.IdOrden;
                                if (psj == null)
                                {
                                }
                                else
                                {
                                    orden.Pesaje.First().IdPesaje = psj.IdPesaje;
                                    _context.Update(orden.Inspeccion.First());
                                }
                            }
                            transaccion.Commit();
                        }
                        catch
                        {
                            transaccion.Rollback();
                            return(View("~/Views/Shared/Error.cshtml"));

                            throw;
                        }
                        await _context.SaveChangesAsync();
                    }
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!OrdenExists(orden.IdOrden))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View());
        }
 void Start()
 {
     conteo = GameObject.FindGameObjectWithTag("Player").GetComponent <Conteo>();
 }
Esempio n. 12
0
        public async void Generar()
        {
            for (int i = 2006; i <= 2019; i++)
            {
                List <int> vacunaciones = new List <int>()
                {
                    _rand.Next(2, 4), _rand.Next(5, 7), _rand.Next(10, 13)
                };
                // Todos se dan entre el dia 05 - 25
                for (int j = 1; j <= 12; j++)
                {
                    var inicio = DateTime.Parse(string.Format("05/{0}/{1}", j, i));
                    var fin    = DateTime.Parse(string.Format("25/{0}/{1}", j, i));
                    var fecha  = FechaAleatoria(inicio, fin);

                    bool existeInspeccion = false;
                    bool existeVacunacion = false;
                    bool existePesaje     = false;
                    using (SCGContext context = new SCGContext())
                    {
                        using (var transaction = context.Database.BeginTransaction())
                        {
                            var ganado = await context.Ganado.Where(x => x.Estado == Ganado.Estados.Activo && x.FechaIngreso <= fecha).ToListAsync();

                            var orden = new Orden()
                            {
                                FechaPlanificacion = fecha,
                                Razon = string.Empty
                            };

                            context.Orden.Add(orden);
                            await context.SaveChangesAsync();

                            var conteo = new Conteo()
                            {
                                IdOrden = orden.IdOrden
                            };
                            context.Conteo.Add(conteo);
                            await context.SaveChangesAsync();

                            var inspeccion = new Inspeccion()
                            {
                                IdOrden = orden.IdOrden
                            };
                            if (_rand.NextDouble() < ProbabilidadInspeccion)
                            {
                                context.Inspeccion.Add(inspeccion);
                                await context.SaveChangesAsync();

                                existeInspeccion = true;
                            }

                            var pesaje = new Pesaje()
                            {
                                IdOrden = orden.IdOrden
                            };
                            if (_rand.NextDouble() < ProbabilidadPesaje)
                            {
                                context.Pesaje.Add(pesaje);
                                await context.SaveChangesAsync();

                                existePesaje = true;
                            }

                            // Mes de vacunacion
                            Vacunacion vacunacion = new Vacunacion()
                            {
                                IdOrden = orden.IdOrden
                            };
                            int vacunasMax   = _rand.Next(2, 5);
                            var listaVacunas = vacunasRandom(vacunasMax);
                            if (vacunaciones.Exists(x => x == j))
                            {
                                context.Vacunacion.Add(vacunacion);
                                await context.SaveChangesAsync();

                                for (int k = 0; k < listaVacunas.Count; k++)
                                {
                                    PlanificacionVacunacion pv = new PlanificacionVacunacion()
                                    {
                                        IdVacunacion = vacunacion.IdVacunacion
                                    };
                                    pv.IdVacuna = listaVacunas[k];
                                    context.PlanificacionVacunacion.Add(pv);
                                    await context.SaveChangesAsync();
                                }
                                existeVacunacion = true;
                            }


                            /// A PARTIR DE ACA SE COMPLETAN LAS ACTIVIDADES
                            foreach (var val in ganado)
                            {
                                ResultadoConteo rc = new ResultadoConteo()
                                {
                                    IdConteo = conteo.IdConteo, IdGanado = val.IdGanado, Asistencia = 0
                                };
                                if (_rand.NextDouble() < ProbabilidadAsistencia)
                                {
                                    rc.Asistencia = 1;
                                }
                                else
                                {
                                    rc.Asistencia = 0;
                                }

                                context.ResultadoConteo.Add(rc);
                                await context.SaveChangesAsync();

                                if (existeInspeccion)
                                {
                                    if (_rand.NextDouble() < ProbabilidadPadecimiento)
                                    {
                                        var ri = new ResultadoInspeccion()
                                        {
                                            IdInspeccion = inspeccion.IdInspeccion, IdGanado = val.IdGanado
                                        };
                                        context.ResultadoInspeccion.Add(ri);
                                        await context.SaveChangesAsync();

                                        InspeccionPadecimiento ip = new InspeccionPadecimiento()
                                        {
                                            IdResultadoInspeccion = ri.IdResultadoInspeccion
                                        };
                                        ip.IdPadecimiento = Padecimientos[_rand.Next(0, Padecimientos.Count)];
                                        context.InspeccionPadecimiento.Add(ip);
                                        await context.SaveChangesAsync();
                                    }
                                }

                                if (existePesaje)
                                {
                                    bool invierno = false;
                                    var  rp       = new ResultadoPesaje()
                                    {
                                        IdGanado = val.IdGanado, IdPesaje = pesaje.IdPesaje
                                    };
                                    int edad = (int)Math.Round((fecha - val.FechaNacimiento).Value.TotalDays / 365);
                                    if (fecha.Month > 4 && fecha.Month < 9)
                                    {
                                        invierno = true;
                                    }
                                    rp.Peso = calcularPeso(edad, invierno);

                                    context.ResultadoPesaje.Add(rp);
                                    await context.SaveChangesAsync();
                                }

                                if (existeVacunacion)
                                {
                                    var rv = new ResultadoVacunacion()
                                    {
                                        IdGanado = val.IdGanado, IdVacunacion = vacunacion.IdVacunacion
                                    };
                                    context.ResultadoVacunacion.Add(rv);
                                    await context.SaveChangesAsync();

                                    for (int k = 0; k < listaVacunas.Count; k++)
                                    {
                                        var va = new VacunaAplicada()
                                        {
                                            IdResultadoVacunacion = rv.IdResultadoVacunacion, IdVacuna = listaVacunas[k]
                                        };
                                        context.VacunaAplicada.Add(va);
                                        await context.SaveChangesAsync();
                                    }
                                }
                            }

                            transaction.Commit();
                        }
                    }
                }
            }
        }