public IList <AdminToDoViewModel> GetRaceCreateErrors(
RaceWithOptionsViewModel race)
{
var returnList = new List <AdminToDoViewModel>();
if (race == null)
{
return(returnList);
}
if (race.FleetOptions == null || race.FleetOptions.Count == 0)
{
returnList.Add(new AdminToDoViewModel
{
Title = "Add a class of boat",
Details = "Even if the club only sails one type of boat, you need to set up a class to use SailScores. A fleet for each class will be automatically set up.",
Link = new ToDoLinkViewModel
{
Action = "Create",
Controller = "BoatClass"
},
Completed = false,
});
}
if (!race.ClubHasCompetitors && (race.CompetitorOptions == null || race.CompetitorOptions.Count == 0))
{
returnList.Add(new AdminToDoViewModel
{
Title = "Add competitors",
Details = "Before adding a race, set up the competitors.",
Link = new ToDoLinkViewModel
{
Action = "CreateMultiple",
Controller = "Competitor"
},
Completed = false
});
}
if ((returnList?.Count ?? 0) >= 1 &&
(race.SeriesOptions == null || race.SeriesOptions.Count == 0))
{
returnList.Add(new AdminToDoViewModel
{
Title = "Add a series",
Details = "If you want to score races together, add a series.",
Link = new ToDoLinkViewModel
{
Action = "Create",
Controller = "Series"
},
Completed = false
});
}
return(returnList);
}
public async Task <ActionResult> Create(
string clubInitials,
RaceWithOptionsViewModel race,
string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
RaceWithOptionsViewModel raceOptions =
await _raceService.GetBlankRaceWithOptions(
clubInitials,
race.RegattaId,
race.SeriesIds?.FirstOrDefault());
race.ScoreCodeOptions = raceOptions.ScoreCodeOptions;
race.FleetOptions = raceOptions.FleetOptions;
race.CompetitorBoatClassOptions = raceOptions.CompetitorBoatClassOptions;
race.CompetitorOptions = raceOptions.CompetitorOptions;
race.SeriesOptions = raceOptions.SeriesOptions;
race.WeatherIconOptions = raceOptions.WeatherIconOptions;
race.UseAdvancedFeatures = raceOptions.UseAdvancedFeatures;
return(View(race));
}
var clubId = await _clubService.GetClubId(clubInitials);
if (!await _authService.CanUserEdit(User, clubId))
{
return(Unauthorized());
}
race.ClubId = clubId;
race.UpdatedBy = await GetUserStringAsync();
await _raceService.SaveAsync(race);
if (!string.IsNullOrWhiteSpace(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Admin"));
}
public async Task <IActionResult> Edit(
string clubInitials,
Guid id,
RaceWithOptionsViewModel race,
string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
ViewData["ClubInitials"] = clubInitials;
if (!await _authService.CanUserEdit(User, race.ClubId))
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
RaceWithOptionsViewModel raceOptions =
await _raceService.GetBlankRaceWithOptions(
clubInitials,
race.RegattaId,
race.SeriesIds?.FirstOrDefault());
race.ScoreCodeOptions = raceOptions.ScoreCodeOptions;
race.FleetOptions = raceOptions.FleetOptions;
race.CompetitorBoatClassOptions = raceOptions.CompetitorBoatClassOptions;
race.CompetitorOptions = raceOptions.CompetitorOptions;
race.SeriesOptions = raceOptions.SeriesOptions;
race.UseAdvancedFeatures = raceOptions.UseAdvancedFeatures;
foreach (var score in race.Scores)
{
score.Competitor = raceOptions.CompetitorOptions.First(c => c.Id == score.CompetitorId);
}
return(View(race));
}
race.UpdatedBy = await GetUserStringAsync();
await _raceService.SaveAsync(race);
return(RedirectToLocal(returnUrl));
}
public async Task <ActionResult> Create(
string clubInitials,
Guid?regattaId,
Guid?seriesId,
string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
RaceWithOptionsViewModel race =
await _raceService.GetBlankRaceWithOptions(
clubInitials,
regattaId,
seriesId);
var errors = _adminTipService.GetRaceCreateErrors(race);
if (errors != null && errors.Count > 0)
{
return(View("CreateErrors", errors));
}
_adminTipService.AddTips(ref race);
return(View(race));
}
public void AddTips(ref RaceWithOptionsViewModel race)
{
if (race == null)
{
return;
}
if ((race.SeriesOptions == null || race.SeriesOptions.Count == 0))
{
race.Tips = new List <AdminToDoViewModel> {
new()
{
Title = "Add a series",
Details = "If you want to score races together, add a series and a season covering this date.",
Link = new ToDoLinkViewModel
{
Action = "Create",
Controller = "Series"
},
Completed = false
}
};
}
}
private async Task <RaceWithOptionsViewModel> CreateClubRaceAsync(string clubInitials)
{
var club = await _coreClubService.GetMinimalClub(clubInitials);
var model = new RaceWithOptionsViewModel
{
ClubId = club.Id,
FleetOptions = await _coreClubService.GetActiveFleets(club.Id),
SeriesOptions = await _coreSeriesService.GetAllSeriesAsync(club.Id, DateTime.Today, false),
ScoreCodeOptions = (await _coreScoringService.GetScoreCodesAsync(club.Id))
.OrderBy(s => s.Name).ToList(),
CompetitorOptions = new List <Competitor>(),
CompetitorBoatClassOptions = (await _coreClubService.GetAllBoatClasses(club.Id)).OrderBy(c => c.Name),
Date = DateTime.Today,
Weather = await _weatherService.GetCurrentWeatherForClubAsync(club),
WeatherIconOptions = GetWeatherIconOptions(),
ClubHasCompetitors = await _coreClubService.DoesClubHaveCompetitors(club.Id),
NeedsLocalDate = true,
UseAdvancedFeatures = club.UseAdvancedFeatures ?? false
};
return(model);
}
public async Task AddOptionsToRace(RaceWithOptionsViewModel raceWithOptions)
{
if (raceWithOptions.RegattaId.HasValue)
{
raceWithOptions.FleetOptions = await _coreClubService.GetAllFleets(raceWithOptions.ClubId);
}
else
{
raceWithOptions.FleetOptions = await _coreClubService.GetActiveFleets(raceWithOptions.ClubId);
}
raceWithOptions.FleetOptions = raceWithOptions.FleetOptions.OrderBy(f => f.ShortName).ToList();
raceWithOptions.SeriesOptions = await _coreSeriesService.GetAllSeriesAsync(
raceWithOptions.ClubId,
raceWithOptions.Date.HasValue?raceWithOptions.Date.Value : DateTime.Today,
true);
raceWithOptions.ScoreCodeOptions = (await _coreScoringService.GetScoreCodesAsync(raceWithOptions.ClubId))
.OrderBy(s => s.Name).ToList();
// CompetitorOptions should be set by the JS on the page at edit time.
raceWithOptions.CompetitorBoatClassOptions =
(await _coreClubService.GetAllBoatClasses(raceWithOptions.ClubId)).OrderBy(c => c.Name);
raceWithOptions.WeatherIconOptions = _weatherService.GetWeatherIconOptions();
}
public async Task SaveAsync(RaceWithOptionsViewModel race)
{
await EnsureSeasonExists(race.ClubId, race.Date);
var fleets = await _coreClubService.GetAllFleets(race.ClubId);
var series = await _coreSeriesService.GetAllSeriesAsync(race.ClubId, DateTime.Today, false);
// fill in series and fleets
if (race.SeriesIds != null)
{
race.Series = series.Where(s => race.SeriesIds.Contains(s.Id)).ToList();
}
if (race.FleetId != default)
{
race.Fleet = fleets.Single(f => f.Id == race.FleetId);
// if a regatta race, give everyone in the fleet a result
if (race.RegattaId.HasValue)
{
foreach (var competitor in race.Fleet.Competitors)
{
if (!race.Scores?.Any(s => s.CompetitorId == competitor.Id) ?? false)
{
race.Scores.Add(new ScoreViewModel
{
CompetitorId = competitor.Id,
Code = "DNC",
Race = _mapper.Map <Race>(race)
});
}
}
}
}
if (race.Order == 0)
{
if (race.InitialOrder.HasValue && race.InitialOrder.Value != 0)
{
race.Order = race.InitialOrder.Value;
}
else
{
int existingRaceCount = await _coreRaceService.GetRaceCountAsync(
race.ClubId,
race.Date,
race.FleetId);
race.Order = existingRaceCount + 1;
}
}
var raceDto = _mapper.Map <RaceDto>(race);
if ((raceDto.SeriesIds?.Count ?? 0) != (race?.SeriesIds?.Count ?? 0))
{
raceDto.SeriesIds = race.SeriesIds;
}
if (race.Weather != null)
{
var weatherSettings = (await _coreClubService.GetMinimalClub(race.ClubId)).WeatherSettings;
if (String.IsNullOrWhiteSpace(race.Weather.WindSpeedUnits))
{
race.Weather.WindSpeedUnits = weatherSettings?.WindSpeedUnits;
}
if (String.IsNullOrWhiteSpace(race.Weather.TemperatureUnits))
{
race.Weather.TemperatureUnits = weatherSettings?.TemperatureUnits;
}
}
var weather = _weatherService.GetStandardWeather(race.Weather);
raceDto.Weather = _mapper.Map <WeatherDto>(weather);
var raceId = await _coreRaceService.SaveAsync(raceDto);
race.Id = raceId;
if (race.RegattaId.HasValue)
{
await _coreRegattaService.AddRaceToRegattaAsync(
_mapper.Map <Race>(race), race.RegattaId.Value);
}
}
