예제 #1
0
        public async Task <IActionResult> PutTerrain(Guid id, Terrain terrain)
        {
            if (id != terrain.IdTerrain)
            {
                return(BadRequest());
            }

            _context.Entry(terrain).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TerrainExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
예제 #2
0
        public async Task <IActionResult> PutAddress(string id, Address address)
        {
            if (id != address.gouv)
            {
                return(BadRequest());
            }

            _context.Entry(address).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AddressExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutClub(Guid id, Club club)
        {
            if (id != club.IdClub)
            {
                return(BadRequest());
            }

            _context.Entry(club).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClubExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
 public ActionResult Edit([Bind(Include = "ClubId,ClubName,CreationDate,adminID")] Club club)
 {
     if (ModelState.IsValid)
     {
         db.Entry(club).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(club));
 }
예제 #5
0
        public async Task <IActionResult> AddClubAction(IFormCollection data)
        {
            int count = _dbContext.Clubs.OrderBy(c => - c.Id).Take(1).ToList()[0].Id;

            Console.WriteLine(count);
            var club = new Club()
            {
                Id       = count + 1,
                Name     = data["Name"],
                Logo     = data["Logo"],
                LeagueId = Int32.Parse(data["LeagueId"])
            };

            _dbContext.Add(club);
            _dbContext.SaveChanges();

            for (int i = 1; i <= 11; i++)
            {
                var player = new Player()
                {
                    Name     = data["PlayerName_" + i],
                    Age      = 22,
                    Photo    = "",
                    Nation   = "USSR",
                    Flag     = "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a9/Flag_of_the_Soviet_Union.svg/800px-Flag_of_the_Soviet_Union.svg.png",
                    Score    = Int32.Parse(data["PlayerScore_" + i]),
                    Position = data["PlayerPosition_" + i],
                    Number   = Int32.Parse(data["PlayerNumber_" + i]),
                    ClubId   = club.Id
                };
                _dbContext.Entry(player).State = EntityState.Added;
                _dbContext.SaveChanges();
            }

            return(View());
        }
예제 #6
0
        public async Task PlaySeason(string season)
        {
            var s = new Season()
            {
                Name = season
            };
            ClubsContext dbContext = new ClubsContext();

            dbContext.Entry(s).State = EntityState.Added;
            dbContext.SaveChanges();
            MainController mainController = new MainController(dbContext);

            mainController.SeasonPlay(s);

            await Clients.All.SendAsync("PlaySeason", "Season is played look at stats");
        }
예제 #7
0
        public async Task <bool> Handle(UpdateMatchTeamsCommand request, CancellationToken cancellationToken)
        {
            var convertedMatch = _Mapper.Map <Match>(request.Match);
            var existingRecord = await _Context.Matches
                                 .Include(m => m.Teams)
                                 .FirstOrDefaultAsync(m => m.Id == convertedMatch.Id);

            // if found we need to update then save changes!
            if (existingRecord != null)
            {
                _Context.Entry(existingRecord).CurrentValues.SetValues(convertedMatch);
                existingRecord.Teams = convertedMatch.Teams;
                _Context.Update(existingRecord);

                _Context.Teams.AddRange(existingRecord.Teams);

                return((await _Context.SaveChangesAsync()) > 0);
            }
            return(false);
        }
예제 #8
0
        public async Task <bool> Handle(UpdateClubCommand request, CancellationToken cancellationToken)
        {
            var existingBlog = _Context.Clubs.Find(request.Club.Id);

            if (existingBlog != null)
            {
                _Context.Entry(existingBlog).CurrentValues.SetValues(request.Club);
            }

            try
            {
                return((await _Context.SaveChangesAsync()) > 0);
            }
            catch (DbUpdateException /* ex */)
            {
                //Log the error (uncomment ex variable name and write a log.)
                // ModelState.AddModelError("", "Unable to save changes. " +
                //     "Try again, and if the problem persists, " +
                //     "see your system administrator.");
                return(false);
            }
        }
예제 #9
0
        public async Task <bool> Handle(UpdateMemberCommand request, CancellationToken cancellationToken)
        {
            var existingRecord = _Context.Members.Find(request.Member.Id);

            if (existingRecord != null)
            {
                _Context.Entry(existingRecord).CurrentValues.SetValues(request.Member);
            }
            try
            {
                return((await _Context.SaveChangesAsync()) > 0);
            }
            catch (DbUpdateException ex)
            {
                //Log the error (uncomment ex variable name and write a log.)
                _Logger.LogError($"SqlError - Unable to save changes: {ex.Message}");
                // ModelState.AddModelError("", "Unable to save changes. " +
                //     "Try again, and if the problem persists, " +
                //     "see your system administrator.");
                return(false);
            }
        }
예제 #10
0
        public async Task <IActionResult> PutReservation(Guid id, Reservation reservation)
        {
            var resu = await _context.Reservations.FindAsync(id);

            if (resu == null)
            {
                return(BadRequest());
            }

            DateTime NewreservationStart = Convert.ToDateTime(reservation.StartReservation);
            DateTime NewreservationEnd   = Convert.ToDateTime(reservation.EndReservation);


            if (resu.StartReservation != reservation.StartReservation || resu.EndReservation != reservation.EndReservation)
            {
                var terrain = await _context.Terrains.Include(t => t.Reservations).SingleOrDefaultAsync(r => r.IdTerrain == resu.IdTerrain);

                if (terrain == null)
                {
                    return(BadRequest(new { message = "Stadium not found" }));
                }
                //var club = await _context.Terrains.SingleOrDefaultAsync(t => t.IdClub == terrain.IdClub);

                if (DateTime.Compare(NewreservationStart, DateTime.Now) < 0)
                {
                    return(BadRequest(new { message = "This Date has been passed" }));
                }

                if (DateTime.Compare(NewreservationStart, NewreservationEnd) == 0 || DateTime.Compare(NewreservationStart, NewreservationEnd) == 1)
                {
                    return(BadRequest(new { message = "The given Date is invalid" }));
                }
                if (DateTime.Compare(NewreservationStart, Convert.ToDateTime(resu.StartReservation)) == -1 || DateTime.Compare(NewreservationStart, Convert.ToDateTime(resu.EndReservation)) == 1)
                {
                    var reservations = terrain.Reservations;
                    foreach (var res in reservations)
                    {
                        if (DateTime.Compare(NewreservationStart, Convert.ToDateTime(res.StartReservation)) == 0)
                        {
                            return(BadRequest(new { message = "This ReservationDate is invalid" }));
                        }
                        else
                        {
                            if (DateTime.Compare(NewreservationStart, Convert.ToDateTime(res.EndReservation)) == -1 && DateTime.Compare(NewreservationStart, Convert.ToDateTime(res.StartReservation)) == 1)
                            {
                                return(BadRequest(new { message = "This Reservation StartDate is invalid" }));
                            }
                        }
                    }
                }
                if (DateTime.Compare(NewreservationEnd, Convert.ToDateTime(resu.EndReservation)) == 1 || DateTime.Compare(NewreservationEnd, Convert.ToDateTime(resu.StartReservation)) == -1)
                {
                    var reservations = terrain.Reservations;
                    foreach (var res in reservations)
                    {
                        if (DateTime.Compare(NewreservationEnd, Convert.ToDateTime(res.EndReservation)) == 0)
                        {
                            return(BadRequest(new { message = "This ReservationDate is invalid" }));
                        }
                        else
                        {
                            if (DateTime.Compare(NewreservationEnd, Convert.ToDateTime(res.EndReservation)) == -1 && DateTime.Compare(NewreservationEnd, Convert.ToDateTime(res.StartReservation)) == 1)
                            {
                                return(BadRequest(new { message = "This Reservation EndDate is invalid" }));
                            }
                        }
                    }
                }
            }

            var terr = await _context.Terrains.Include(t => t.Reservations).SingleOrDefaultAsync(r => r.IdTerrain == resu.IdTerrain);

            resu.StartReservation = reservation.StartReservation;
            resu.EndReservation   = reservation.EndReservation;
            resu.Duration         = ((NewreservationEnd - NewreservationStart).TotalHours).ToString();
            resu.Price            = Double.Parse(resu.Duration) * terr.Price;
            resu.status           = reservation.status;

            _context.Entry(resu).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ReservationExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }