public async Task <IActionResult> Edit(string id, [Bind("StyleName,Description")] Style style)
{
if (id != style.StyleName)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(style);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StyleExists(style.StyleName))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(style));
}
public async Task <IActionResult> Edit(int id, [Bind("ArtistId,MinimumHourlyRate,NameAddressid")] Artist artist)
{
if (id != artist.ArtistId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(artist);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ArtistExists(artist.ArtistId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["NameAddressid"] = new SelectList(_context.NameAddress, "NameAddressId", "NameAddressId", artist.NameAddressid);
return(View(artist));
}
public async Task <IActionResult> Edit(string id, [Bind("CountryCode,Name,PostalPattern,PhonePattern,FederalSalesTax,ProvinceTerminology")] Country country)
{
if (id != country.CountryCode)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(country);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CountryExists(country.CountryCode))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(country));
}
public async Task <IActionResult> Edit(int id, [Bind("NameAddressId,FirstName,LastName,CompanyName,StreetAddress,City,PostalCode,ProvinceCode,Email,Phone")] NameAddress nameAddress)
{
if (id != nameAddress.NameAddressId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(nameAddress);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NameAddressExists(nameAddress.NameAddressId))
{
return(NotFound());
}
else
{
throw;
}
}
TempData["Message"] = "Update successful.";
return(RedirectToAction(nameof(Index)));
}
ViewData["ProvinceCode"] = new SelectList(_context.Province.OrderBy(a => a.Name), "Name", "Name");
return(View(nameAddress));
}
public async Task <IActionResult> Edit(int id, [Bind("ClubId,Name,Phone,StyleCode")] Club club)
{
if (id != club.ClubId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(club);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClubExists(club.ClubId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StyleCode"] = new SelectList(_context.Style, "StyleCode", "StyleCode", club.StyleCode);
return(View(club));
}
public async Task <IActionResult> Edit(int id, [Bind("InstrumentId,Name")] Instrument instrument)
{
if (id != instrument.InstrumentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(instrument);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstrumentExists(instrument.InstrumentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(instrument));
}
public async Task <IActionResult> Edit(int id, [Bind("ArtistIdGroup,ArtistIdMember,DateJoined,DateLeft")] GroupMember groupMember)
{
if (ModelState.IsValid)
{
try
{
_context.Update(groupMember);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GroupMemberExists(groupMember.ArtistIdGroup))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ArtistIdGroup"] = new SelectList(_context.Artist, "ArtistId", "ArtistId", groupMember.ArtistIdGroup);
ViewData["ArtistIdMember"] = new SelectList(_context.Artist, "ArtistId", "ArtistId", groupMember.ArtistIdMember);
return(View(groupMember));
}
public async Task <IActionResult> Edit(int id, [Bind("ContractId,StartDate,GroupId,ClubId,PricePerPerformace,NumberOfPerformances,TotalPrice")] Contract contract)
{
//Adding Current club Name in the Viewbag to send it ti the view
ViewBag.ClubName = HttpContext.Session.GetString("SesClubName");
if (id != contract.ContractId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contract);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContractExists(contract.ContractId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ClubId"] = new SelectList(_context.Club, "ClubId", "Name", contract.ClubId);
ViewData["GroupId"] = new SelectList(_context.Groups, "GroupId", "Name", contract.GroupId);
return(View(contract));
}
public ActionResult Edit(Country country)
{
if (ModelState.IsValid)
{
_context.Update(country);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(country));
}
public async Task <IActionResult> Edit(string id, [Bind("ProvinceCode,Name,CountryCode,SalesTaxCode,SalesTax,IncludesFederalTax,FirstPostalLetter")] Province province)
{
string errorsMsg = "";
if (id != province.ProvinceCode)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
// ensure province name does not exist under different key
Province prov = _context.Province.FirstOrDefault(
p => p.Name == province.Name && // find province records with the same name
p.ProvinceCode != province.ProvinceCode // skip the current province to be updated, check other records
);
if (prov != null)
{
errorsMsg += $"'{prov.Name}' is already taken - use a different Name.";
}
if (errorsMsg == "")
{
_context.Update(province);
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!ProvinceExists(province.ProvinceCode))
{
return(NotFound());
}
else
{
throw;
}
}
if (errorsMsg == "")
{
return(RedirectToAction(nameof(Index)));
}
}
if (errorsMsg != "")
{
TempData["message"] = errorsMsg;
}
ViewData["CountryCode"] = new SelectList(_context.Country, "CountryCode", "CountryCode", province.CountryCode);
return(View(province));
}
public async Task <bool> Handle(UpdateMatchDetailsCommand request, CancellationToken cancellationToken)
{
var existingRecord = await _Context.Matches
.Include(m => m.Teams)
.FirstOrDefaultAsync(m => m.Id == request.Match.Id);
// if found we need to update then save changes!
if (existingRecord != null)
{
existingRecord.Date = request.Match.Date;
existingRecord.Location = request.Match.Location;
existingRecord.Status = request.Match.Status;
_Context.Update(existingRecord);
return((await _Context.SaveChangesAsync()) > 0);
}
return(false);
}
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);
}
public async Task <IActionResult> Edit(int id, [Bind("ArtistIdGroup,ArtistIdMember,DateJoined,DateLeft")] GroupMember groupMember)
{
if (id != groupMember.ArtistIdMember ||
groupMember.ArtistIdGroup != Convert.ToInt32(HttpContext.Session.GetString("artistId")))
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(groupMember);
await _context.SaveChangesAsync();
TempData["message"] = "Record updated successfully";
}
catch (DbUpdateConcurrencyException ex)
{
if (!GroupMemberExists(groupMember.ArtistIdMember))
{
ModelState.AddModelError("", $"group member is not on file {groupMember.ArtistIdMember}");
}
else
{
ModelState.AddModelError("", $"concurrency exception: {ex.GetBaseException().Message}");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", $"update error: {ex.GetBaseException().Message}");
}
return(RedirectToAction(nameof(Index)));
}
//ViewData["ArtistIdGroup"] = new SelectList(_context.Artist, "ArtistId", "ArtistId", groupMember.ArtistIdGroup);
//ViewData["ArtistIdMember"] = new SelectList(_context.Artist, "ArtistId", "ArtistId", groupMember.ArtistIdMember);
return(View(groupMember));
}
public async Task <IActionResult> Edit(string id, [Bind("ProvinceCode,Name,CountryCode,SalesTaxCode,SalesTax,IncludesFederalTax,FirstPostalLetter")] Province province)
{
var existingName = _context.Province.Where(p => p.Name == province.Name).FirstOrDefault(); // pulls
if (existingName != null)
{
TempData["Message"] = "That province name already exists.";
return(View(province));
}
if (id != province.ProvinceCode)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(province);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProvinceExists(province.ProvinceCode))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CountryCode"] = new SelectList(_context.Country, "CountryCode", "CountryCode", province.CountryCode);
return(View(province));
}
public async Task <IActionResult> Edit(int id, [Bind("NameAddressId,FirstName,LastName,CompanyName,StreetAddress,City,PostalCode,ProvinceCode,Email,Phone")] NameAddress nameAddress)
{
if (id != nameAddress.NameAddressId)
{
ModelState.AddModelError("", "A record being updated is not the one requested.");
}
if (ModelState.IsValid)
{
try
{
_context.Update(nameAddress);
await _context.SaveChangesAsync();
TempData["message"] = $"Name & Address record updated successfully";
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateConcurrencyException ex)
{
if (!NameAddressExists(nameAddress.NameAddressId))
{
ModelState.AddModelError("", $"NameAddressId is not on file: {nameAddress.NameAddressId}");
}
else
{
ModelState.AddModelError("", $"Concurrency exception: {ex.GetBaseException().Message}");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", $"Error while updating a record: {ex.GetBaseException().Message}");
}
}
// display the province name in the drop-down, ordered by name
ViewData["ProvinceCode"] = new SelectList(_context.Province.OrderBy(p => p.Name), "ProvinceCode", "Name", nameAddress.ProvinceCode);
return(View(nameAddress));
}
public Game Play(Club a, Club b, string season = "Training", string league = "Training", bool notFinal = true)
{
int homePlus = 0;
if (notFinal)
{
homePlus += 3;
}
Random rnd = new Random();
var aPlayers = _dbContext.Players.Where(p => p.ClubId == a.Id).OrderBy(p => - p.Score).Take(11).ToList();
var bPlayers = _dbContext.Players.Where(p => p.ClubId == b.Id).OrderBy(p => - p.Score).Take(11).ToList();
int aAvg, bAvg, sumA = 0, sumB = 0;
string [] defenders = new string[7] {
"RB", "RWB", "CB", "LB", "LWB", "LCB", "RCB"
};
string[] midlefields = new string[13] {
"CDM", "CM", "CAM", "RM", "RW", "LM", "LW", "LCM", "RCM", "LDM", "RAM", "LAM", "RDM"
};
string[] attackers = new string[6] {
"CF", "RF", "LF", "ST", "LS", "RS"
};
// A Team
var aAttackers = new List <Player>();
var aMidleFields = new List <Player>();;
var aDefenders = new List <Player>();;
foreach (var aPlayer in aPlayers)
{
sumA += aPlayer.Score;
if (attackers.Contains(aPlayer.Position))
{
aAttackers.Add(aPlayer);
}
else if (midlefields.Contains(aPlayer.Position))
{
aMidleFields.Add(aPlayer);
}
else if (defenders.Contains(aPlayer.Position))
{
aDefenders.Add(aPlayer);
}
}
var aPlayingClub = aAttackers.Concat(aMidleFields).ToList();
aPlayingClub = aPlayingClub.Concat(aDefenders).ToList();
aAvg = sumA / 11;
// B Team
var bAttackers = new List <Player>();
var bMidleFields = new List <Player>();
var bDefenders = new List <Player>();
foreach (var bPlayer in bPlayers)
{
sumB += bPlayer.Score;
if (attackers.Contains(bPlayer.Position))
{
bAttackers.Add(bPlayer);
}
else if (midlefields.Contains(bPlayer.Position))
{
bMidleFields.Add(bPlayer);
}
else if (defenders.Contains(bPlayer.Position))
{
bDefenders.Add(bPlayer);
}
}
var bPlayingClub = bAttackers.Concat(bMidleFields).ToList();
bPlayingClub = bPlayingClub.Concat(bDefenders).ToList();
bAvg = sumB / 11;
string aGoals = "";
string bGoals = "";
int aScore = 0;
int bScore = 0;
for (int i = 0; i < 90; i++)
{
if (rnd.Next(1, 51 - Math.Abs(aAvg - bAvg)) == 1)
{
if (rnd.Next(aAvg, 101 + homePlus) > rnd.Next(bAvg, 101))
{
foreach (var aPlayer in aPlayingClub)
{
if (rnd.Next(0, 2) == 1)
{
aGoals += aPlayer.Name + " " + i + ", ";
aScore++;
if (_dbContext.TopScorers.FirstOrDefault(c => c.PlayerId == aPlayer.Id && c.League == league && c.Season == season) != null)
{
var topScorer = _dbContext.TopScorers.FirstOrDefault(c =>
c.PlayerId == aPlayer.Id && c.League == league && c.Season == season);
topScorer.Count++;
_dbContext.Update(topScorer);
_dbContext.SaveChanges();
}
else
{
var topScorer = new TopScorers()
{
PlayerId = aPlayer.Id,
Count = 1,
League = league,
Season = season
};
_dbContext.Entry(topScorer).State = EntityState.Added;
_dbContext.SaveChanges();
}
break;
}
}
}
else
{
foreach (var bPlayer in bPlayingClub)
{
if (rnd.Next(0, 2) == 1)
{
bGoals += bPlayer.Name + " " + i + ", ";
bScore++;
if (_dbContext.TopScorers.FirstOrDefault(c => c.PlayerId == bPlayer.Id && c.League == league && c.Season == season) != null)
{
var topScorer = _dbContext.TopScorers.FirstOrDefault(c =>
c.PlayerId == bPlayer.Id && c.League == league && c.Season == season);
topScorer.Count++;
_dbContext.Update(topScorer);
_dbContext.SaveChanges();
}
else
{
var topScorer = new TopScorers()
{
PlayerId = bPlayer.Id,
Count = 1,
League = league,
Season = season
};
_dbContext.Entry(topScorer).State = EntityState.Added;
_dbContext.SaveChanges();
}
break;
}
}
}
}
}
string winner;
if (aScore > bScore)
{
winner = a.Name;
}
else if (bScore > aScore)
{
winner = b.Name;
}
else
{
winner = "Draw";
}
var game = new Game()
{
HomeClub = a.Name,
GuestClub = b.Name,
League = league,
Season = season,
HomeGoals = aGoals,
GuestGoals = bGoals,
HomeScore = aScore,
GuestScore = bScore,
Winner = winner
};
_dbContext.Entry(game).State = EntityState.Added;
_dbContext.SaveChanges();
return(game);
}