public async Task <IActionResult> Edit(int id, [Bind("Id,PlayerId,GameDate,Assist,Error,Putout,DoublePlay")] FieldingStats fieldingStats)
{
if (id != fieldingStats.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(fieldingStats);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FieldingStatsExists(fieldingStats.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Details", "Players", new { id = fieldingStats.PlayerId }));
}
ViewData["PlayerId"] = new SelectList(_context.Player, "Id", "ApplicationUserId", fieldingStats.PlayerId);
return(View(fieldingStats));
}
public void GetFieldingStatsReturnsEnumerableFieldingRecords()
{
var expectedPerson = new FieldingStats
{
Pos = "C",
PlayerId = "personId"
};
var secondPerson = new FieldingStats
{
Pos = "P",
PlayerId = "personId"
};
var expectedPeople = new List <FieldingStats>()
{
expectedPerson,
secondPerson
};
_fieldingService.Setup(mockFieldingService => mockFieldingService.GetFieldingStats(expectedPerson.PlayerId)).Returns(expectedPeople);
var actualPerson = _controller.GetFieldingStats(expectedPerson.PlayerId);
Assert.That(actualPerson.ElementAt(0), Is.EqualTo(expectedPerson));
Assert.That(actualPerson.ElementAt(1), Is.EqualTo(secondPerson));
}
public void AssertGetFieldingStatsReturnsStats(Fielding expectedPerson)
{
var expectedPersonStats = new FieldingStats();
_mockMapper.Setup(mockFieldingMapper => mockFieldingMapper.Map(expectedPerson)).Returns(expectedPersonStats);
var actualFielding = _service.GetFieldingStats(expectedPerson.PlayerId);
Assert.That(actualFielding.ElementAt(0), Is.EqualTo(expectedPersonStats));
}
public void AssertGetFieldingStatsReturnsStatsWithDuplicateId(Fielding firstEntry, Fielding secondEntry)
{
var firstEntryStats = new FieldingStats();
var secondEntryStats = new FieldingStats();
_mockMapper.Setup(mockFieldingMapper => mockFieldingMapper.Map(firstEntry)).Returns(firstEntryStats);
_mockMapper.Setup(mockFieldingMapper => mockFieldingMapper.Map(secondEntry)).Returns(secondEntryStats);
var actualPeople = _service.GetFieldingStats(firstEntry.PlayerId);
Assert.That(actualPeople.ElementAt(0), Is.EqualTo(firstEntryStats));
Assert.That(actualPeople.ElementAt(1), Is.EqualTo(secondEntryStats));
}
public async Task <IActionResult> Create([Bind("PlayerId,GameDate,Assist,Error,Putout,DoublePlay")] FieldingStats fieldingStats)
{
if (ModelState.IsValid)
{
_context.Add(fieldingStats);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["PlayerId"] = new SelectList(_context.Player, "Id", "ApplicationUserId", fieldingStats.PlayerId);
return(View(fieldingStats));
}
public void MapCopiesDataFromFieldingToFieldingStats()
{
Fielding fielding = GenerateFieldingWithoutNullValues();
FieldingStats fieldingStats = _mapper.Map(fielding);
AssertThatEachElementIsEqual(fielding, fieldingStats);
Fielding fieldingWithNull = GenerateFieldingWithNullValues();
FieldingStats fieldingStatsWithNull = _mapper.Map(fieldingWithNull);
AssertThatEachElementIsEqual(fieldingWithNull, fieldingStatsWithNull);
}
/// <summary>
/// Loads the fielding stats.
/// </summary>
/// <param name="roster">Player[]</param>
/// <param name="directory">string</param>
private static void LoadFieldingStats(ref Player[] roster, string directory)
{
FieldingStats[] fStats = FieldingStats.LoadFieldingStats(TextUtilities.FormFilePathName(directory, "Fielding", ".dat"));
foreach (Player player in roster)
{
foreach (FieldingStats fStat in fStats)
{
if (player.FullName.Equals(fStat.Name))
{
player.FieldingStats = fStat;
player.FieldingStatistics = new FieldingStatisticsContainer(player);
}
}
}
}
public void TestLoadFieldingStatsFromFile()
{
int expectedLines = 45;
string path = @"./Data/BaseballReference/Arizona Diamondbacks_(2001)/Arizona Diamondbacks_(2001) Fielding.dat";
Assert.IsTrue(File.Exists(path));
try
{
FieldingStats[] fStats = FieldingStats.LoadFieldingStats(path);
Assert.IsTrue(fStats.Length == expectedLines);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void AssertThatEachElementIsEqual(Fielding fielding, FieldingStats fieldingStats)
{
Assert.That(fieldingStats.PlayerId, Is.EqualTo(fielding.PlayerId));
Assert.That(fieldingStats.YearId, Is.EqualTo(fielding.YearId));
Assert.That(fieldingStats.Stint, Is.EqualTo(fielding.Stint));
Assert.That(fieldingStats.TeamId, Is.EqualTo(fielding.TeamId));
Assert.That(fieldingStats.LgId, Is.EqualTo(fielding.LgId));
Assert.That(fieldingStats.G, Is.EqualTo(fielding.G));
Assert.That(fieldingStats.Pos, Is.EqualTo(fielding.Pos));
Assert.That(fieldingStats.Gs, Is.EqualTo(fielding.Gs));
Assert.That(fieldingStats.InnOuts, Is.EqualTo(fielding.InnOuts));
Assert.That(fieldingStats.Po, Is.EqualTo(fielding.Po));
Assert.That(fieldingStats.A, Is.EqualTo(fielding.A));
Assert.That(fieldingStats.E, Is.EqualTo(fielding.E));
Assert.That(fieldingStats.Dp, Is.EqualTo(fielding.Dp));
Assert.That(fieldingStats.Pb, Is.EqualTo(fielding.Pb));
Assert.That(fieldingStats.Sb, Is.EqualTo(fielding.Sb));
Assert.That(fieldingStats.Cs, Is.EqualTo(fielding.Cs));
Assert.That(fieldingStats.Wp, Is.EqualTo(fielding.Wp));
Assert.That(fieldingStats.Zr, Is.EqualTo(fielding.Zr));
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
builder.Entity <Team>()
.HasMany(t => t.Players)
.WithOne(p => p.Team)
.OnDelete(DeleteBehavior.Restrict);
ApplicationUser user = new ApplicationUser
{
FirstName = "Ima",
LastName = "Parent",
UserName = "******",
NormalizedUserName = "******",
PhoneNumber = "615-555-5555",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
EmailConfirmed = true,
LockoutEnabled = false,
SecurityStamp = "7f434309-a4d9-48e9-9ebb-8803db794577",
Id = "00000000-ffff-ffff-ffff-ffffffffffff",
IsCoach = false
};
var passwordHash = new PasswordHasher <ApplicationUser>();
user.PasswordHash = passwordHash.HashPassword(user, "P@r3nt");
builder.Entity <ApplicationUser>().HasData(user);
Player player = new Player
{
Id = 1,
FirstName = "Johnny",
LastName = "Jones",
Nickname = "JJ",
Age = 9,
Position = "Shortstop",
ApplicationUserId = user.Id,
TeamId = 1
};
builder.Entity <Player>().HasData(player);
Team team = new Team
{
Id = 1,
Name = "The Hooks",
Mascot = "Fish Hook",
TeamAffiliation = "Houston Astros",
ApplicationUserId = user.Id
};
builder.Entity <Team>().HasData(team);
BattingStats battingStats = new BattingStats
{
Id = 1,
PlayerId = 1,
GameDate = new DateTime(2019, 9, 5),
AtBat = 3,
Hit = 2,
Single = 2,
Double = 0,
Triple = 0,
HomeRun = 0,
RunsBattedIn = 1,
RunsScored = 1,
Walk = 0,
Strikeout = 0
};
builder.Entity <BattingStats>().HasData(battingStats);
FieldingStats fieldingStats = new FieldingStats
{
Id = 1,
PlayerId = 1,
GameDate = new DateTime(2019, 9, 5),
Assist = 0,
Error = 1,
Putout = 1,
DoublePlay = 0
};
builder.Entity <FieldingStats>().HasData(fieldingStats);
}
/// <summary>
/// Loads FieldingStats[] array from database.
/// </summary>
/// <returns>GameStats[]</returns>
/// <param name="dataTable">DataTable</param>
protected override GameStats[] LoadStatsFromDatabase(DataTable dataTable)
{
//Players can have multiple rows if they play several positions
List <FieldingStats> fieldingStats = new List <FieldingStats>();
try
{
foreach (DataRow row in this.dataTable.Rows)
{
FieldingStats fStats = null;
string name = String.Concat(row["nameFirst"].ToString(), " ", row["nameLast"].ToString());
int putOuts = Convert.ToInt32(row["PO"]);
int assists = Convert.ToInt32(row["A"]);
int errors = Convert.ToInt32(row["E"]);
int totalChances = putOuts + assists + errors;
int fieldingRating = 0;
int groundballError = 0;
int flyoutError = 0;
if (totalChances >= 10)
{
putOuts = Convert.ToInt32(row["PO"]);
assists = Convert.ToInt32(row["A"]);
fieldingRating = Constants.GetValueFromDouble(putOuts + assists, totalChances);
groundballError = Constants.GetValueFromDouble(errors, totalChances);
if (groundballError == 0)
{
groundballError = 1;
}
flyoutError = Constants.GetValueFromDouble(errors, totalChances);
if (flyoutError == 0)
{
flyoutError = 1;
}
}
else//Generate stats
{
fieldingRating = Dice.Roll(90, 100);
groundballError = 100 - fieldingRating;
flyoutError = 100 - fieldingRating;
}
fStats = new FieldingStats(fieldingRating, groundballError, flyoutError);
fStats.NaturalPosition = row["POS"].ToString();
fStats.Name = name;
//Determine arm strength for Catchers
if (fStats.NaturalPosition == "C")
{
try
{
fStats.ArmStrength = (int)Constants.GetValueFromDouble(Convert.ToInt32(row["SB"]), (Convert.ToInt32(row["SB"]) + Convert.ToInt32(row["CS"])));
if (fStats.ArmStrength < 0)
{
fStats.ArmStrength = Convert.ToInt32(ConfigurationManager.GetConfigurationValue("DEFAULT_CATCHER_ARM_STRENGTH"));
}
}
catch (Exception ex)
{
ex.ToString();
fStats.ArmStrength = Convert.ToInt32(ConfigurationManager.GetConfigurationValue("DEFAULT_CATCHER_ARM_STRENGTH"));
}
}
else if (fStats.NaturalPosition == "P")
{
fStats.ArmStrength = Convert.ToInt32(ConfigurationManager.GetConfigurationValue("DEFAULT_PITCHER_ARM_STRENGTH"));;
}
else
{
fStats.ArmStrength = Convert.ToInt32(ConfigurationManager.GetConfigurationValue("DEFAULT_FIELDER_ARM_STRENGTH"));;
}
fieldingStats.Add(fStats);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
fieldingStats.Add(new FieldingStats(98, 5, 5, 75));
}
return(fieldingStats.ToArray());
}
