public ActionResult Create([Bind(Include = "IDCampeonatoGrupo,IDGrupo,IDInscrito,dDataCadastro")] CampeonatoGrupo campeonatoGrupo)
        {
            if (ModelState.IsValid)
            {
                if (campeonatoGrupo.IDInscrito == 0 || campeonatoGrupo.IDGrupo == 0)
                {
                    ViewBag.ListaCampeonato = db.Campeonato.Where(p => p.iTipoCampeonato == TipoCampeonato.Grupos);
                    return(RedirectToAction("Create").ComMensagem("Time inscrito ou grupo é obrigatorio.", "alert-warning"));
                }

                if (db.CampeonatoGrupo.Where(p => p.IDInscrito == campeonatoGrupo.IDInscrito).Count() > 0)
                {
                    ViewBag.ListaCampeonato = db.Campeonato.Where(p => p.iTipoCampeonato == TipoCampeonato.Grupos);
                    return(View(campeonatoGrupo).ComMensagem("Já existe uma inscrição para este time.", "alert-warning"));
                }

                db.CampeonatoGrupo.Add(campeonatoGrupo);
                db.SaveChanges();
                return(RedirectToAction("Index").ComMensagem("Operação realizada com sucesso.", "alert-success"));
            }

            ViewBag.ListaCampeonato = db.Campeonato.Where(p => p.iTipoCampeonato == TipoCampeonato.Grupos);

            return(View(campeonatoGrupo));
        }
        // GET: CampeonatoGrupo/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CampeonatoGrupo campeonatoGrupo = db.CampeonatoGrupo.Find(id);

            if (campeonatoGrupo == null)
            {
                return(HttpNotFound());
            }
            return(View(campeonatoGrupo));
        }
 public ActionResult DeleteConfirmed(int id)
 {
     try
     {
         CampeonatoGrupo campeonatoGrupo = db.CampeonatoGrupo.Find(id);
         db.CampeonatoGrupo.Remove(campeonatoGrupo);
         db.SaveChanges();
         return(RedirectToAction("Index").ComMensagem("Operação realizada com sucesso.", "alert-success"));
     }
     catch (Exception)
     {
         return(RedirectToAction("Index").ComMensagem("Este registro não pode ser apagado, ele possui dependências.", "alert-danger"));
     }
 }
示例#4
0
        // GET: PartidaCampeonato/Create
        public ActionResult GerarPartidasCampeonato()
        {
            CampeonatoGrupo       campeonatoGrupo = new CampeonatoGrupo();
            IEnumerable <IDGrupo> actionTypes     = Enum.GetValues(typeof(IDGrupo))
                                                    .Cast <IDGrupo>();

            ViewBag.ListaGrupos = from action in actionTypes
                                  select new SelectListItem
            {
                Text  = action.ToString(),
                Value = ((int)action).ToString()
            };


            ViewBag.ListaCampeonato = db.Campeonato;
            return(View());
        }
        public ActionResult Edit([Bind(Include = "IDCampeonatoGrupo,IDGrupo,IDInscrito,dDataCadastro")] CampeonatoGrupo campeonatoGrupo)
        {
            if (ModelState.IsValid)
            {
                db.Entry(campeonatoGrupo).State = EntityState.Modified;
                db.Entry(campeonatoGrupo).Property("dDataCadastro").IsModified = false;
                db.Entry(campeonatoGrupo).Property("IDInscrito").IsModified    = false;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.IDInscrito = new SelectList(db.Inscrito.Select(x => new SelectListItem
            {
                Text  = x.PreInscrito.Time.sNome.ToUpper(),
                Value = x.IDInscrito.ToString()
            }), "Value", "Text");

            return(View(campeonatoGrupo));
        }
        // GET: CampeonatoGrupo/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CampeonatoGrupo campeonatoGrupo = db.CampeonatoGrupo.Find(id);

            if (campeonatoGrupo == null)
            {
                return(HttpNotFound());
            }
            ViewBag.IDInscrito = new SelectList(db.Inscrito.Select(x => new SelectListItem
            {
                Text  = x.PreInscrito.Time.sNome.ToUpper(),
                Value = x.IDInscrito.ToString()
            }), "Value", "Text", campeonatoGrupo.IDInscrito);

            return(View(campeonatoGrupo));
        }
示例#7
0
        public ActionResult GerarPartidasCampeonato(int?IDCampeonato, int?IDGrupoP)
        {
            try
            {
                ViewBag.ListaCampeonato = db.Campeonato;

                CampeonatoGrupo       campeonatoGrupo = new CampeonatoGrupo();
                IEnumerable <IDGrupo> actionTypes     = Enum.GetValues(typeof(IDGrupo))
                                                        .Cast <IDGrupo>();
                ViewBag.ListaGrupos = from action in actionTypes
                                      select new SelectListItem
                {
                    Text  = action.ToString(),
                    Value = ((int)action).ToString()
                };

                Random rnd        = new Random();
                int    qtde_times = 0;
                //int iRodada = 1;
                //int iQntdJogoTimeRodada = 0;
                int      iQntdRodadas = 0;
                int      cont         = 0;
                int      turno        = 0;
                int[]    timesInscritos;
                string[] partidas;


                if (IDCampeonato == null)
                {
                    return(View().ComMensagem("Selecione o Campeonato.", "alert-warning"));
                }
                else
                {
                    var campeonato = db.Campeonato.Find(IDCampeonato);


                    switch (campeonato.iTipoCampeonato)
                    {
                    case TipoCampeonato.Grupos:

                        if (IDGrupoP == null)
                        {
                            return(View().ComMensagem("Selecione o grupo.", "alert-warning"));
                        }
                        else
                        {
                            IDGrupo grupo = (IDGrupo)Enum.ToObject(typeof(IDGrupo), IDGrupoP);

                            var inscritosGrupos = db.CampeonatoGrupo.Where(p => p.IDGrupo == grupo && p.Inscrito.PreInscrito.IDCampeonato == IDCampeonato).ToList();

                            int[] timesGrupo = new int[inscritosGrupos.Count];

                            foreach (CampeonatoGrupo e in inscritosGrupos)
                            {
                                timesGrupo[cont] = e.IDInscrito;
                                cont++;
                            }

                            timesInscritos = timesGrupo;
                        }
                        break;

                    case TipoCampeonato.MataMata:
                        return(View().ComMensagem("Regra do Mata-Mata não foi emplementada.", "alert-warning"));

                    default:

                        var inscritos = db.Inscrito.Where(p => p.PreInscrito.Campeonato.IDCampeonato == IDCampeonato).ToList();

                        int[] times = new int[inscritos.Count];

                        foreach (Inscrito e in inscritos)
                        {
                            times[cont] = e.IDInscrito;
                            cont++;
                        }

                        timesInscritos = times;
                        break;
                    }


                    qtde_times = timesInscritos.Count(); // Quantidade de Times

                    if (qtde_times % 2 == 0)
                    {
                        iQntdRodadas = qtde_times - 1;
                    }
                    else
                    {
                        iQntdRodadas = qtde_times;
                    }

                    if (campeonato.bIdaVolta)
                    {
                        turno    = 2;
                        partidas = new string[calculaFatorial(qtde_times) / calculaFatorial(qtde_times - 2)];
                    }
                    else
                    {
                        turno    = 1;
                        partidas = new string[calculaFatorial(qtde_times) / calculaFatorial(qtde_times - 2) / 2];
                    }

                    cont = 0;

                    for (int t = 0; t < turno; t++)
                    {
                        for (int i = 0; i < qtde_times; i++)
                        {     //For para caminhar entre os times
                            for (int j = i; j < qtde_times; j++)
                            { //For para caminha entre os adversários
                                if (timesInscritos[i] != timesInscritos[j])
                                {
                                    using (var transaction = db.Database.BeginTransaction())
                                    {
                                        try
                                        {
                                            PartidaCampeonato partidaCampeonato = new PartidaCampeonato();
                                            partidaCampeonato.IDInscrito1   = timesInscritos[i];
                                            partidaCampeonato.IDInscrito2   = timesInscritos[j];
                                            partidaCampeonato.iQntGols1     = 0;
                                            partidaCampeonato.iQntGols2     = 0;
                                            partidaCampeonato.dDataPartida  = DateTime.Now;
                                            partidaCampeonato.dDataCadastro = DateTime.Now;
                                            partidaCampeonato.sHoraPartida  = "";
                                            partidaCampeonato.iRodada       = 0;

                                            db.PartidaCampeonato.Add(partidaCampeonato);
                                            db.SaveChanges();

                                            Sumula sumula = new Sumula();

                                            sumula.IDPartidaCampeonato = partidaCampeonato.IDPartidaCampeonato;
                                            sumula.sObservacao         = "";
                                            sumula.dDataCadastro       = DateTime.Now;
                                            db.Sumula.Add(sumula);
                                            db.SaveChanges();

                                            transaction.Commit();
                                        }
                                        catch (Exception ex)
                                        {
                                            ex.Message.ToString();
                                            transaction.Rollback();
                                        }
                                    }
                                    //verifica pra não deixar jogar um time contra ele mesmo
                                    //partidaCampeonato.IDInscrito1 = timesInscritos[i];
                                    //partidaCampeonato.IDInscrito2 = timesInscritos[j];
                                    //partidaCampeonato.iQntGols1 = 0;
                                    //partidaCampeonato.iQntGols2 = 0;
                                    //partidaCampeonato.dDataPartida = DateTime.Now;
                                    //partidaCampeonato.dDataCadastro = DateTime.Now;
                                    //partidaCampeonato.sHoraPartida = "";

                                    //iQntdJogoTimeRodada = db.PartidaCampeonato.Where(p => p.iRodada == iRodada && (p.IDInscrito1 == partidaCampeonato.IDInscrito1 || p.IDInscrito2 == partidaCampeonato.IDInscrito1 || p.IDInscrito1 == partidaCampeonato.IDInscrito2 || p.IDInscrito2 == partidaCampeonato.IDInscrito2)).Count();

                                    //while (iQntdJogoTimeRodada == 0)
                                    //{
                                    //    iRodada = rnd.Next(1, iQntdRodadas);

                                    //    iQntdJogoTimeRodada = db.PartidaCampeonato.Where(p => p.iRodada == iRodada && (p.IDInscrito1 == partidaCampeonato.IDInscrito1 || p.IDInscrito2 == partidaCampeonato.IDInscrito1 || p.IDInscrito1 == partidaCampeonato.IDInscrito2 || p.IDInscrito2 == partidaCampeonato.IDInscrito2)).Count();

                                    //    cont++;

                                    //    if (cont >= qtde_times + iQntdRodadas)
                                    //    {
                                    //        iRodada = qtde_times;
                                    //        break;
                                    //    }
                                    //}

                                    //cont = 0;

                                    //partidaCampeonato.iRodada = iRodada;
                                    //partidaCampeonato.iRodada = 1;

                                    //db.PartidaCampeonato.Add(partidaCampeonato);
                                    //db.SaveChanges();
                                }
                            }
                        }
                    }
                }
            }
            catch (DbEntityValidationException dbEx)
            {
                foreach (var validationErrors in dbEx.EntityValidationErrors)
                {
                    foreach (var validationError in validationErrors.ValidationErrors)
                    {
                        System.Console.WriteLine("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
                    }
                }
                return(View().ComMensagem("Erro ao realizar a operação.", "alert-danger"));
            }

            return(RedirectToAction("Index").ComMensagem("Partidas geradas com sucesso.", "alert-success"));
        }