public async Task <IActionResult> Create(Bracket bracket)
        {
            bracket.Rounds = new List <Round>();

            if (ModelState.IsValid)
            {
                _context.Add(bracket);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            PopulateAssignedContenderData(bracket);
            return(View(bracket));
        }
示例#2
0
        public async Task <IActionResult> Create([Bind("EntrantID,Name,Tag")] Entrant entrant)
        {
            if (ModelState.IsValid)
            {
                var files = HttpContext.Request.Form.Files;
                foreach (var Image in files)
                {
                    if (Image != null && Image.Length > 0)
                    {
                        var file    = Image;
                        var uploads = Path.Combine(_hostingEnvironment.WebRootPath, "images/uploads");

                        if (file.Length > 0)
                        {
                            var fileName       = HeaderUtilities.RemoveQuotes(file.FileName).ToString();
                            var fileType       = fileName.Split('.').Last();
                            var uniqueFileName = string.Format(@"{0}." + fileType, DateTime.Now.Ticks);

                            using (var fileStream = new FileStream(Path.Combine(uploads, uniqueFileName), FileMode.Create))
                            {
                                await file.CopyToAsync(fileStream);

                                entrant.Thumbnail = uniqueFileName;
                            }
                        }
                    }
                }

                _context.Add(entrant);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(View(entrant));
        }
        public async Task <IActionResult> Create([Bind("ContenderID,EntrantID,BracketID,Eliminated,RoundsAlive")] Contender contender)
        {
            if (ModelState.IsValid)
            {
                _context.Add(contender);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            ViewData["EntrantID"] = new SelectList(_context.Entrants, "EntrantID", "Name", contender.EntrantID);
            return(View(contender));
        }
        public async Task <IActionResult> Create(BoardCreateViewModel bingoBoardViewModel)
        {
            List <int> positions = new List <int>();

            for (int i = 0; i < REQUIRED_PIECES; i++)
            {
                positions.Add(i);
            }

            // TODO: validate distinct
            //var distinctEntrants = bingoBoard.Entrants.Select(e => e.EntrantID).Distinct().ToList();

            var rand    = new Random(DateTime.Now.Millisecond);
            var bracket = _context.Brackets
                          .Include(b => b.Contenders)
                          .Include(b => b.Rounds)
                          .Single(b => b.BracketID == bingoBoardViewModel.BracketID);

            var bracketEntrants = bracket.Contenders.Select(b => b.EntrantID).ToList();
            var contenders      = new List <Contender>();
            var roundId         = bracket.Rounds != null && bracket.Rounds.Count == 1 ? bracket.Rounds.First().RoundID : -1;

            for (int i = 0; i < bingoBoardViewModel.Entrants.Count; i++)
            {
                Contender contender;
                if (!bracketEntrants.Contains(bingoBoardViewModel.Entrants[i]))
                {
                    contender = new Contender
                    {
                        BracketID = bracket.BracketID,
                        EntrantID = bingoBoardViewModel.Entrants[i],
                    };

                    _context.Add(contender);

                    if (roundId != -1)
                    {
                        _context.Add(new RoundContender {
                            RoundID = roundId, ContenderID = contender.ContenderID
                        });
                    }
                }
                else
                {
                    contender = bracket.Contenders.Single(c => c.EntrantID == bingoBoardViewModel.Entrants[i]);
                }

                contenders.Add(contender);
            }

            //await _context.SaveChangesAsync();

            var bingoBoard = new BingoBoard
            {
                BracketID       = bracket.BracketID,
                Title           = bingoBoardViewModel.Title,
                RoundEliminated = -1
            };

            bingoBoard.BoardPieces = new List <BoardPiece>();
            for (int i = 0; i < contenders.Count; i++)
            {
                var pos             = i == 0 ? positions.Count / 2 : rand.Next(0, positions.Count);
                var boardPieceToAdd = new BoardPiece {
                    BingoBoardID = bingoBoard.BingoBoardID, ContenderID = contenders[i].ContenderID, BoardPosition = positions[pos]
                };
                positions.Remove(positions[pos]);

                bingoBoard.BoardPieces.Add(boardPieceToAdd);
            }

            if (ModelState.IsValid)
            {
                _context.Add(bingoBoard);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Manage", "Brackets", new { id = bingoBoard.BracketID }));
            }

            return(View(bingoBoard));
        }