public async Task AddCompetitorAsync(Competition competition, PersonCompetitor competitor)
{
var expert = calculatorManager.Find(competition.Discipline);
if (expert == null)
{
throw new InvalidDisciplineException();
}
using (var transaction = context.UseOrBeginTransaction(IsolationLevel.RepeatableRead))
try
{
if (competitor.StartNumber == 0 || expert.AutomaticStartNumbers)
{
var highest = await(from d in context.Competitors
where d.ListId == competitor.ListId
select d.StartNumber).DefaultIfEmpty(0).MaxAsync();
competitor.StartNumber = Math.Max(expert.AutomaticStartNumberFrom, highest + 1);
}
competitor.EntityId = competitor.Person?.Id ?? competitor.PersonId;
await AddCompetitorAsync(competitor);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
public async Task <PersonCompetitor> AddNewCompetitorAsync(Competition competition, Guid listId, PersonLicense license, CompetitorStatus status, CompetitorSource source)
{
await context.LoadAsync(license, l => l.Club);
var @class = await LicensesWorkflow.GetPersonLicenseVenueClassAsync(license, competition.VenueCode, competition.Discipline, competition.Starts);
var competitor = new PersonCompetitor
{
ListId = listId,
Person = license.Person,
Name = license.Person.Name,
ShortName = new string(license.Person.Name.PrefixedSurname.Take(50).ToArray()),
LicenseDiscipline = license.Discipline,
LicenseKey = license.Key,
LicenseFlags = license.Flags,
Gender = license.Person.Gender,
Status = status,
Category = license.Category,
Class = @class,
Sponsor = license.Sponsor,
ClubCountryCode = license.ClubCountryCode,
ClubCode = license.ClubCode,
ClubShortName = license.Club?.ShortName,
ClubFullName = license.Club?.FullName,
From = license.Person.Address.City,
StartNumber = license.Number ?? 0,
NationalityCode = license.Person.NationalityCode,
VenueCode = license.VenueCode,
Transponder1 = license.Transponder1,
Transponder2 = license.Transponder2,
Source = source
};
await AddCompetitorAsync(competition, competitor);
return(competitor);
}
public async Task <ICollection <PersonCompetitor> > LoadFromStreamAsync(Guid competitionId, Guid listId, Stream stream)
{
using (var context = contextFactory())
{
var distanceCombinations = await(from dc in context.DistanceCombinations
where dc.CompetitionId == competitionId
select dc).ToDictionaryAsync(dc => dc.Number, dc => dc.Id);
using (var transaction = context.BeginTransaction(IsolationLevel.RepeatableRead))
using (var reader = new StreamReader(stream, Encoding))
using (var csv = new CsvReader(reader, configuration))
try
{
var competitors = new List <PersonCompetitor>();
while (csv.Read())
{
if (csv.CurrentRecord.Length < 3)
{
throw new FormatException(string.Format(Resources.TooFewFields, 8, csv.Row));
}
var key = csv.GetField(0);
var license = await context.PersonLicenses.Include(pl => pl.Club)
.Include(pl => pl.Person)
.FirstOrDefaultAsync(pl => pl.IssuerId == LongTrackLicenses.IssuerId && pl.Discipline == LongTrackLicenses.Discipline && pl.Key == key);
if (license == null)
{
throw new PersonNotFoundException(string.Format(Resources.PersonLicenseKeyNotFound, LongTrackLicenses.IssuerId, LongTrackLicenses.Discipline,
key));
}
var combinations = csv.GetField(1).Split(new[] { '+' }, StringSplitOptions.RemoveEmptyEntries).Select(g => int.Parse(g.Trim()));
int startNumber;
if (!int.TryParse(csv.GetField(2), NumberStyles.None, CultureInfo.InvariantCulture, out startNumber))
{
throw new FormatException(string.Format(Resources.InvalidStartNumber, csv.GetField(2), csv.Row));
}
var category = csv.CurrentRecord.Length >= 4 ? csv.GetField(3) : license.Category;
var name = csv.CurrentRecord.Length >= 9 ? new Name(null, csv.GetField(6), csv.GetField(7), csv.GetField(8)) : license.Person.Name;
var shortName = csv.CurrentRecord.Length >= 5 ? csv.GetField(4) : name.ToInitialNameString();
var competitor = new PersonCompetitor
{
Id = Guid.NewGuid(),
EntityId = license.PersonId,
ListId = listId,
PersonId = license.PersonId,
Name = name,
ShortName = shortName,
LicenseDiscipline = LongTrackLicenses.Discipline,
LicenseKey = license.Key,
LicenseFlags = license.Flags,
Gender = license.Person.Gender,
Status = CompetitorStatus.Confirmed,
Category = category,
ClubCountryCode = license.Club?.CountryCode,
ClubCode = license.Club?.Code,
ClubShortName = license.Club?.ShortName,
ClubFullName = license.Club?.FullName,
From = license.Person.Address.City,
StartNumber = startNumber,
NationalityCode = license.Person.NationalityCode,
VenueCode = license.VenueCode,
Source = CompetitorSource.Manual,
Added = DateTime.UtcNow
};
context.Competitors.Add(competitor);
foreach (var combination in combinations.Where(combination => distanceCombinations.ContainsKey(combination)))
{
context.DistanceCombinationCompetitors.Add(new DistanceCombinationCompetitor
{
Competitor = competitor,
DistanceCombinationId = distanceCombinations[combination],
Status = DistanceCombinationCompetitorStatus.Confirmed
});
}
competitors.Add(competitor);
await context.SaveChangesAsync();
}
transaction.Commit();
return(competitors);
}
catch
{
transaction.Rollback();
throw;
}
}
}
public async Task <IList <RecordTime> > GetRecordsBrokeAsync(IDisciplineCalculator calculator, Distance distance, PersonCompetitor competitor, TimeSpan time)
{
if (distance.Competition == null)
{
throw new ArgumentNullException(nameof(distance), Resources.DistanceCompetitionIsNull);
}
if (competitor.Person == null)
{
throw new ArgumentNullException(nameof(competitor), Resources.PersonCompetitorPersonIsNull);
}
var season = calculator.Season(distance.Competition.Starts);
var age = calculator.SeasonAge(season, competitor.Person.BirthDate);
return(await(from rt in context.RecordTimes
where rt.LicenseIssuerId == distance.Competition.LicenseIssuerId &&
rt.Discipline == distance.Competition.Discipline &&
rt.DistanceDiscipline == distance.Discipline &&
rt.Distance == distance.Value &&
rt.Gender == competitor.Person.Gender &&
((rt.Type == RecordType.National || rt.Type == RecordType.World) ||
(rt.Type == RecordType.Track && rt.VenueCode == distance.VenueCode) ||
(rt.Type == RecordType.TrackAge && rt.VenueCode == distance.VenueCode && rt.FromAge <= age && rt.ToAge >= age)) &&
time < rt.Time
select rt).ToListAsync());
}
