private async Task ExportScheduleAsync(ICompetitionContext context, Guid competitionId, Stream stream, CultureInfo culture)
{
var distances = await(from d in context.Distances.Include(r => r.Races)
where d.CompetitionId == competitionId
orderby d.Number
select new
{
d.Number,
d.Rounds,
Races = d.Races.Select(r => new
{
r.Round,
r.Heat
}).Distinct()
}).ToListAsync();
using (var writer = new StreamWriter(stream, Encoding))
using (var csv = new CsvWriter(writer))
foreach (var distance in distances)
{
for (var round = 1; round <= distance.Rounds; round++)
{
foreach (var race in distance.Races.Where(r => r.Round == round).OrderBy(r => r.Heat).ToList())
{
csv.WriteField(distance.Number);
csv.WriteField(round);
csv.WriteField(race.Heat);
csv.NextRecord();
}
}
}
}
internal static async Task <MassStartTranspondersReport> LoadAsync(ICompetitionContext context, Guid competitionId, Guid distanceId,
OptionalReportColumns optionalColumns)
{
var report = new MassStartTranspondersReport();
var distance = await context.Distances.Include(d => d.Competition.Venue).Include(d => d.Competition.ReportTemplate.Logos).FirstOrDefaultAsync(d => d.Id == distanceId);
if (distance == null)
{
throw new DistanceNotFoundException();
}
report.SetParameters(distance);
var races = await context.Races.Include(r => r.Competitor)
.Include(r => r.Transponders)
.Where(r => r.DistanceId == distanceId)
.OrderBy(r => r.Round)
.ThenBy(r => r.Heat)
.ThenBy(r => r.Lane)
.ToListAsync();
report.Races = races;
return(report);
}
private static async Task ExportPeopleAsync(ICompetitionContext context, Guid competitionId, Func <string, Stream> streamFactory, CultureInfo culture)
{
var lists = await(from c in context.Competitors.OfType <PersonCompetitor>()
where c.List.CompetitionId == competitionId && c.Status == CompetitorStatus.Confirmed
group c by new
{
c.ListId,
c.List.SortOrder,
c.List.Name
}
into g
select new
{
g.Key.SortOrder,
g.Key.Name,
Competitors = from c in g
select new
{
c.Id,
c.StartNumber,
c.LicenseKey,
c.Name,
c.ClubFullName,
c.NationalityCode
}
}).ToListAsync();
var projection = from l in lists
orderby l.SortOrder, l.Name
select new
{
l.Name,
Competitors = from c in l.Competitors
orderby c.StartNumber
select new
{
c.StartNumber,
c.Name.PrefixedSurname,
c.Name.FirstName,
c.ClubFullName,
c.Id,
c.LicenseKey,
c.NationalityCode
}
};
foreach (var list in projection)
{
using (var writer = new StreamWriter(streamFactory(list.Name), Encoding))
using (var csv = new CsvWriter(writer))
{
writer.WriteLine("; {0}", list.Name);
foreach (var competitor in list.Competitors)
{
csv.WriteRecord(competitor);
}
}
}
}
public RacesWorkflow(ICompetitionContext context, IDistanceDisciplineExpertManager expertManager, IEventRecorder recorder)
{
this.context = context;
this.expertManager = expertManager;
this.recorder = recorder;
context.ProxyCreationEnabled = false;
context.LazyLoadingEnabled = false;
}
public DistanceDrawingWorkflow(ICompetitionContext context, IDisciplineCalculatorManager calculatorManager, IDistanceDisciplineExpertManager distanceExpertManager,
IEventRecorder recorder)
{
this.context = context;
this.calculatorManager = calculatorManager;
this.distanceExpertManager = distanceExpertManager;
personTimesWorkflow = new PersonTimesWorkflow(context, calculatorManager, distanceExpertManager);
distancesWorkflow = new DistancesWorkflow(context, calculatorManager, distanceExpertManager, recorder);
}
public CompetitionsWorkflow(ICompetitionContext context, IDisciplineCalculatorManager calculatorManager, IDistanceDisciplineExpertManager distanceExpertManager,
IEventRecorder recorder)
{
this.context = context;
this.calculatorManager = calculatorManager;
this.recorder = recorder;
this.distanceExpertManager = distanceExpertManager;
DistancesWorkflow = new DistancesWorkflow(context, calculatorManager, distanceExpertManager, recorder);
DistanceCombinationsWorkflow = new DistanceCombinationsWorkflow(context, recorder);
LicensesWorkflow = new LicensesWorkflow(context, calculatorManager, recorder);
RacesWorkflow = new RacesWorkflow(context, distanceExpertManager, recorder);
}
public override Task DrawCompetitorGroupAsync(Distance distance, IReadOnlyCollection <Guid> distanceCombinations, int round, IList <CompetitorBase> competitors,
ICompetitionContext context, DistanceDrawSettings settings)
{
switch (settings.Mode)
{
case DistanceDrawMode.Random:
case DistanceDrawMode.SwitchLanesOrRandom:
competitors.Shuffle();
return(Task.FromResult <object>(null));
default:
throw new DrawModeNotSupportedException();
}
}
private async Task ExportEventAsync(ICompetitionContext context, Guid competitionId, Stream stream, CultureInfo culture)
{
var distances = await(from d in context.Distances
where d.CompetitionId == competitionId
orderby d.Number
select new
{
Value = d,
Races = (from r in d.Races
orderby r.Round, r.Heat, r.Lane
select new
{
r.Round,
r.Heat,
r.Color,
r.Competitor.StartNumber
}).ToList(),
CompetitorCount = (from dc in d.Combinations
from c in dc.Competitors
select c).Distinct().Count()
}).ToListAsync();
using (var writer = new StreamWriter(stream, Encoding))
using (var csv = new CsvWriter(writer))
foreach (var distance in distances)
{
for (var round = 1; round <= distance.Value.Rounds; round++)
{
foreach (var heat in distance.Races.Where(r => r.Round == round).GroupBy(r => r.Heat).ToList())
{
csv.WriteField(distance.Value.Number);
csv.WriteField(round);
csv.WriteField(heat.Key);
csv.WriteField(distance.Value.Name);
csv.NextRecord();
foreach (var race in heat)
{
csv.WriteField("");
csv.WriteField(race.StartNumber);
csv.WriteField(race.Color + 1);
csv.NextRecord();
}
}
}
}
}
public static async Task <Report> LoadAsync(ICompetitionContext context, Guid competitionId, Guid distanceId, int length, OptionalReportColumns optionalColumns)
{
if (length <= 1500)
{
return(await DrawReportLoader <DrawFillIn4Report> .LoadAsync(context, competitionId, distanceId, optionalColumns));
}
if (length <= 5000)
{
return(await DrawReportLoader <DrawFillIn13Report> .LoadAsync(context, competitionId, distanceId, optionalColumns));
}
if (length <= 10000)
{
return(await DrawReportLoader <DrawFillIn25Report> .LoadAsync(context, competitionId, distanceId, optionalColumns));
}
return(null);
}
internal static async Task <RaceTranspondersReport> LoadAsync(ICompetitionContext context, Guid competitionId, Guid distanceId, OptionalReportColumns optionalColumns)
{
var report = new RaceTranspondersReport();
var distance = await context.Distances.Include(d => d.Competition.Venue).Include(d => d.Competition.ReportTemplate.Logos).FirstOrDefaultAsync(d => d.Id == distanceId);
if (distance == null)
{
throw new DistanceNotFoundException();
}
report.SetParameters(distance);
var races = await context.Races.Include(r => r.Competitor).Include(r => r.Transponders).Where(r => r.DistanceId == distanceId).ToListAsync();
await(context.TeamCompetitorMembers
.Include(tcm => tcm.Member)
.Where(tcm => tcm.Team.DistanceCombinations.Any(dc => dc.DistanceCombination.Distances.Any(d => d.Id == distanceId))))
.LoadAsync();
var maxPair = races.Select(r => r.Heat).DefaultIfEmpty(0).Max();
var pairs = new List <Pair>();
for (var pair = distance.FirstHeat; pair <= maxPair; pair++)
{
var colors = PairsDistanceCalculator.Colors(distance, pair);
var innerRace = races.SingleOrDefault(r => r.Heat == pair && r.Lane == 0);
var innerRaceColor = (int)colors.ToLaneColor(Lane.Inner);
var outerRace = races.SingleOrDefault(r => r.Heat == pair && r.Lane == 1);
var outerRaceColor = (int)colors.ToLaneColor(Lane.Outer);
pairs.Add(new Pair(pair, innerRace, innerRaceColor, null, outerRace, outerRaceColor, null));
}
report.Pairs = pairs;
return(report);
}
public abstract Task <IReadOnlyDictionary <int, IReadOnlyCollection <Race> > > FillCompetitorsInHeatsAsync(Distance distance, IReadOnlyCollection <Guid> distanceCombinations, int round, IReadOnlyList <IReadOnlyList <CompetitorBase> > competitorGroups, ICompetitionContext context, DistanceDrawSettings settings);
public virtual Task DrawCompetitorGroupAsync(Distance distance, IReadOnlyCollection <Guid> distanceCombinations, int round, IList <CompetitorBase> competitors, ICompetitionContext context, DistanceDrawSettings settings)
{
throw new DrawModeNotSupportedException();
}
public override async Task <IReadOnlyDictionary <int, IReadOnlyCollection <Race> > > FillCompetitorsInHeatsAsync(Distance distance,
IReadOnlyCollection <Guid> distanceCombinations, int round, IReadOnlyList <IReadOnlyList <CompetitorBase> > competitorGroups, ICompetitionContext context,
DistanceDrawSettings settings)
{
var competitors = competitorGroups.SelectMany(g => g).ToList();
if (!settings.ReverseGroups)
{
competitors.Reverse();
}
var pairCount = (competitors.Count + 1) / 2;
var hasFillPair = distance.StartMode == DistanceStartMode.MultipleHeats && (pairCount % 2) == 1;
if (hasFillPair)
{
pairCount++;
}
var firstHeat = distance.Races.Max(r => new int?(r.Heat)) + 1 ?? distance.FirstHeat;
switch (settings.Mode)
{
case DistanceDrawMode.Random:
return(FillHeatsByCompetitorsOrder(firstHeat, pairCount, hasFillPair, competitors, settings.ReverseFilling, settings.Spreading));
case DistanceDrawMode.SwitchLanesOrRandom:
if (distanceCombinations.Count != 1)
{
throw new DrawModeNotSupportedException();
}
var distanceCombinationId = distanceCombinations.Single();
var previousDistance = await(from d in context.Distances
where d.CompetitionId == distance.CompetitionId && d.Number < distance.Number &&
d.Combinations.Any(dc => dc.Id == distanceCombinationId)
orderby d.Number descending
select new
{
d.Id,
FirstPair = d.FirstHeat
}).FirstOrDefaultAsync();
if (previousDistance == null)
{
return(FillHeatsByCompetitorsOrder(firstHeat, pairCount, hasFillPair, competitors, settings.ReverseFilling, settings.Spreading));
}
var competitorLookup = competitors.ToDictionary(c => c.Id);
var previousPairs = await(from r in context.Races
where r.DistanceId == previousDistance.Id
group r by r.Heat
into heat
select new
{
Pair = heat.Key,
Races = from r in heat
select new
{
r.Lane,
r.CompetitorId
}
}).ToListAsync();
var seed = previousPairs.ToDictionary(p => p.Pair - previousDistance.FirstPair + firstHeat,
p => p.Races.Where(r => competitorLookup.ContainsKey(r.CompetitorId)).ToDictionary(r => (r.Lane + 1) % 2, r => competitorLookup[r.CompetitorId]));
return(FillHeatsByFixedLanes(firstHeat, pairCount, seed));
default:
throw new DrawModeNotSupportedException();
}
}
public override Task <IReadOnlyDictionary <int, IReadOnlyCollection <Race> > > FillCompetitorsInHeatsAsync(Distance distance,
IReadOnlyCollection <Guid> distanceCombinations, int round, IReadOnlyList <IReadOnlyList <CompetitorBase> > competitorGroups, ICompetitionContext context,
DistanceDrawSettings settings)
{
throw new DrawModeNotSupportedException();
}
private async Task ExportDistancesAsync(Competition competition, TextWriter writer, CultureInfo culture, ICompetitionContext context)
{
var distances = await context.Distances
.Include(d => d.Races.Select(r => r.Competitor))
.Include(d => d.Races.Select(r => r.Transponders.Select(t => t.Transponder)))
.Where(d => d.CompetitionId == competition.Id)
.ToListAsync();
var groups = new XElement("groups");
foreach (var distance in distances.OrderBy(dc => dc.Number))
{
var calculator = distanceCalculatorManager.Get(distance.Discipline);
var group = new XElement("group",
new XAttribute("name", $"{distance.Number:00}. {distance.Name}"),
new XElement("competitors",
from r in distance.Races
let personCompetitor = r.Competitor as PersonCompetitor
where personCompetitor != null
orderby personCompetitor.StartNumber
select new XElement("competitor",
new XAttribute("no", personCompetitor.StartNumber),
new XAttribute("driverregistration", personCompetitor.LicenseKey),
new XAttribute("registration", personCompetitor.LicenseKey),
new XAttribute("class", personCompetitor.Category),
new XAttribute("firstname", personCompetitor.Name.FirstName ?? ""),
new XAttribute("lastname", personCompetitor.Name.PrefixedSurname ?? ""),
new XAttribute("transponders", string.Join(",", r.Transponders.Select(t => t.Transponder.Label))),
new XAttribute("additional1", personCompetitor.NationalityCode),
new XAttribute("additional2", personCompetitor.Sponsor ?? ""),
new XAttribute("additional3", personCompetitor.ShortName),
new XAttribute("additional4", personCompetitor.From ?? ""),
new XAttribute("additional5", personCompetitor.ClubFullName ?? ""))));
var starts = InTimeZone(distance.Starts ?? competition.Starts, competition.TimeZone);
var runs = new XElement("runs");
foreach (var heat in distance.Races.GroupBy(r => new { r.Round, r.Heat }).OrderBy(g => g.Key.Round).ThenBy(g => g.Key.Heat))
{
var minimumLapTime = calculator.MininumLapTime(distance);
var run = new XElement("run",
new XAttribute("name", $"{heat.Key.Round:00}.{heat.Key.Heat:000}"),
new XAttribute("shortname", $"{heat.Key.Round:00}.{heat.Key.Heat:000}"),
new XAttribute("date", starts.ToString("yyyy-MM-dd")),
new XAttribute("time", starts.ToString("HH:mm:ss")),
new XAttribute("type", "race"),
new XAttribute("countfirst", "lap"),
new XAttribute("minimumlaptime", minimumLapTime.ToString(@"h\:mm\:ss\.fff")),
new XAttribute("copygroupcompetitor", true),
new XElement("competitors",
from r in heat
let personCompetitor = r.Competitor as PersonCompetitor
where personCompetitor != null
orderby r.Lane
select new XElement("competitor",
new XAttribute("no", personCompetitor.StartNumber),
new XAttribute("driverregistration", personCompetitor.LicenseKey),
new XAttribute("registration", personCompetitor.LicenseKey),
new XAttribute("class", personCompetitor.Category),
new XAttribute("firstname", personCompetitor.Name.FirstName ?? ""),
new XAttribute("lastname", personCompetitor.Name.PrefixedSurname ?? ""),
new XAttribute("transponders", string.Join(",", r.Transponders.Select(t => t.Transponder.Label))),
new XAttribute("additional1", personCompetitor.NationalityCode),
new XAttribute("additional2", personCompetitor.Sponsor ?? ""),
new XAttribute("additional3", personCompetitor.ShortName),
new XAttribute("additional4", personCompetitor.From ?? ""),
new XAttribute("additional5", personCompetitor.ClubFullName ?? ""))));
switch (calculator.HeatStartEvent)
{
case HeatStartEvent.Start:
run.Add(new XAttribute("startmethod", "flag"));
break;
case HeatStartEvent.FirstPassing:
run.Add(new XAttribute("startmethod", "firstpassing"));
break;
}
switch (distance.ValueQuantity)
{
case DistanceValueQuantity.Length:
case DistanceValueQuantity.Count:
run.Add(new XAttribute("autofinishmethod", "individualonlaps"));
run.Add(new XAttribute("autofinishlaps", calculator.Laps(distance)));
break;
}
runs.Add(run);
}
group.Add(runs);
groups.Add(group);
}
var document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"), groups);
document.Save(writer);
}
public DistancePointsTablesWorkflow(ICompetitionContext context)
{
this.context = context;
}
public PersonTimesWorkflow(ICompetitionContext context, IDisciplineCalculatorManager calculatorManager, IDistanceDisciplineExpertManager distanceExpertManager)
{
this.context = context;
this.calculatorManager = calculatorManager;
this.distanceExpertManager = distanceExpertManager;
}
public static async Task <T> LoadAsync(ICompetitionContext context, Guid competitionId, Guid distanceId, OptionalReportColumns optionalColumns)
{
var report = new T();
var distance = await context.Distances
.Include(d => d.Competition.Venue)
.Include(d => d.Competition.ReportTemplate.Logos)
.FirstOrDefaultAsync(d => d.Id == distanceId);
if (distance == null)
{
throw new DistanceNotFoundException();
}
report.SetParameters(distance);
report.ReportParameters["OptionalColumnHeader"].Value = Resources.ResourceManager.GetString($"OptionalColumn_{(int)optionalColumns}") ?? "";
var reportOptionalColumns = report as IPairsDrawReportWithOptionalColumn;
if (reportOptionalColumns != null)
{
switch (optionalColumns)
{
case OptionalReportColumns.HomeVenueCode:
report.ReportParameters["InnerOptionalColumnField"].Value = "Inner.Competitor.VenueCode";
report.ReportParameters["OuterOptionalColumnField"].Value = "Outer.Competitor.VenueCode";
break;
case OptionalReportColumns.NationalityCode:
report.ReportParameters["InnerOptionalColumnField"].Value = "Inner.Competitor.NationalityCode";
report.ReportParameters["OuterOptionalColumnField"].Value = "Outer.Competitor.NationalityCode";
break;
case OptionalReportColumns.ClubShortName:
report.ReportParameters["InnerOptionalColumnField"].Value = "Inner.Competitor.ClubShortName";
report.ReportParameters["OuterOptionalColumnField"].Value = "Outer.Competitor.ClubShortName";
break;
case OptionalReportColumns.LicenseKey:
report.ReportParameters["InnerOptionalColumnField"].Value = "Inner.Competitor.LicenseKey";
report.ReportParameters["OuterOptionalColumnField"].Value = "Outer.Competitor.LicenseKey";
break;
case OptionalReportColumns.SeasonBest:
reportOptionalColumns.InnerOptionalFieldValue = "= SpeedSkating.LongTrack.FormatTime(Fields.Inner.SeasonBest, Parameters.TimeDigits.Value)";
reportOptionalColumns.OuterOptionalFieldValue = "= SpeedSkating.LongTrack.FormatTime(Fields.Outer.SeasonBest, Parameters.TimeDigits.Value)";
break;
default:
report.ReportParameters["OptionalColumnHeader"].Value = string.Empty;
reportOptionalColumns.InnerOptionalFieldValue = null;
reportOptionalColumns.OuterOptionalFieldValue = null;
break;
}
}
var races = await context.Races
.Include(r => r.Competitor)
.Include(r => r.Results)
.Include(r => r.Times)
.Where(r => r.DistanceId == distanceId)
.ToListAsync();
await context.Competitors.OfType <TeamCompetitor>()
.Include(t => t.Members.Select(m => m.Member))
.Where(tc => tc.Races.Any(r => r.DistanceId == distanceId))
.LoadAsync();
var maxPair = races.Select(r => r.Heat).DefaultIfEmpty(0).Max();
var pairs = new List <Pair>();
for (var pair = distance.FirstHeat; pair <= maxPair; pair++)
{
var colors = PairsDistanceCalculator.Colors(distance, pair);
var innerRace = races.SingleOrDefault(r => r.Heat == pair && r.Lane == 0);
var innerRaceColor = (int)colors.ToLaneColor(Lane.Inner);
var outerRace = races.SingleOrDefault(r => r.Heat == pair && r.Lane == 1);
var outerRaceColor = (int)colors.ToLaneColor(Lane.Outer);
pairs.Add(new Pair(pair, innerRace, innerRaceColor, null, outerRace, outerRaceColor, null));
}
report.Pairs = pairs;
return(report);
}
public RecordTimesWorkflow(ICompetitionContext context)
{
this.context = context;
}
private static async Task ImportCompetitionResultsAsync(ICompetitionContext context, Competition current, Competition competition)
{
await ImportReportTemplateAsync(context, competition);
current.ReportTemplate = competition.ReportTemplate;
current.ResultsStatus = CompetitionResultsStatus.Unofficial;
var existingCombinations = await context.DistanceCombinations.Include(dc => dc.Distances).Where(c => c.CompetitionId == competition.Id).ToListAsync();
var existingDistances = await context.Distances.Include(d => d.Combinations).Where(c => c.CompetitionId == competition.Id).ToListAsync();
var existingCompetitorLists = await context.CompetitorLists.Include(cl => cl.Competitors.Select(c => c.DistanceCombinations)).Where(r => r.CompetitionId == competition.Id).ToListAsync();
foreach (var distance in existingDistances.Where(ed => competition.Distances.Any(nd => ed.Id == nd.Id || ed.Number == nd.Number)))
{
distance.Combinations.Clear();
await context.SaveChangesAsync();
context.Distances.Remove(distance);
await context.SaveChangesAsync();
}
var competitorCombinations = new List <DistanceCombinationCompetitor>();
foreach (var list in from ncl in competition.CompetitorLists
join ecl in existingCompetitorLists on ncl.Id equals ecl.Id into g
from ecl in g.DefaultIfEmpty()
select new
{
New = ncl,
Existing = ecl
})
{
if (list.Existing == null)
{
foreach (var competitor in list.New.Competitors)
{
competitorCombinations.AddRange(competitor.DistanceCombinations);
competitor.List = null;
competitor.Races = null;
competitor.DistanceCombinations = null;
}
context.CompetitorLists.Add(list.New);
}
else
{
Mapper.Map(list.New, list.Existing);
await context.SaveChangesAsync();
foreach (var competitor in (from ec in list.Existing.Competitors
join nc in list.New.Competitors on ec.Id equals nc.Id into g
where !g.Any()
select ec).ToList())
{
context.Competitors.Remove(competitor);
await context.SaveChangesAsync();
}
var competitors = (from nc in list.New.Competitors
join ec in list.Existing.Competitors on nc.Id equals ec.Id into g
from ec in g.DefaultIfEmpty()
select new
{
New = nc,
Existing = ec
}).ToList();
foreach (var competitor in competitors.Where(c => c.Existing != null && c.Existing.StartNumber != c.New.StartNumber))
{
competitor.Existing.StartNumber += int.MaxValue / 2;
await context.SaveChangesAsync();
}
foreach (var competitor in competitors)
{
if (competitor.Existing == null)
{
competitorCombinations.AddRange(competitor.New.DistanceCombinations);
competitor.New.List = null;
competitor.New.Races = null;
competitor.New.DistanceCombinations = null;
context.Competitors.Add(competitor.New);
}
else
{
competitorCombinations.AddRange(competitor.New.DistanceCombinations);
Mapper.Map(competitor.New, competitor.Existing);
}
await context.SaveChangesAsync();
}
}
await context.SaveChangesAsync();
}
foreach (var distance in competition.Distances)
{
foreach (var race in distance.Races)
{
race.Competitor = null;
}
if (distance.DistancePointsTable != null)
{
var pointsTable = await context.DistancePointsTables.FirstOrDefaultAsync(t => t.Id == distance.DistancePointsTable.Id);
if (pointsTable == null)
{
context.DistancePointsTables.Add(distance.DistancePointsTable);
}
else
{
distance.DistancePointsTable = pointsTable;
}
}
context.Distances.Add(distance);
}
await context.SaveChangesAsync();
foreach (var combination in (from edc in existingCombinations
join ndc in competition.DistanceCombinations on edc.Id equals ndc.Id into g
where !g.Any()
select edc).ToList())
{
context.DistanceCombinations.Remove(combination);
await context.SaveChangesAsync();
}
var combinations = (from ndc in competition.DistanceCombinations
orderby ndc.Number descending
join edc in existingCombinations on ndc.Id equals edc.Id into g
from edc in g.DefaultIfEmpty()
select new
{
New = ndc,
Existing = edc
}).ToList();
foreach (var combination in combinations.Where(c => c.Existing != null && c.Existing.Number != c.New.Number))
{
combination.Existing.Number += int.MaxValue / 2;
await context.SaveChangesAsync();
}
foreach (var cc in competitorCombinations)
{
cc.DistanceCombination = null;
cc.Competitor = null;
}
foreach (var combination in combinations)
{
if (combination.Existing == null)
{
combination.New.Competitors = competitorCombinations.Where(cc => cc.DistanceCombinationId == combination.New.Id).ToList();
context.DistanceCombinations.Add(combination.New);
}
else
{
Mapper.Map(combination.New, combination.Existing);
combination.Existing.Competitors = competitorCombinations.Where(cc => cc.DistanceCombinationId == combination.Existing.Id).ToList();
combination.Existing.Distances = competition.Distances.Where(nd => combination.New.Distances.Any(ed => ed.Id == nd.Id)).ToList();
}
await context.SaveChangesAsync();
}
}
private async Task ExportDistanceCombinationsAsync(Competition competition, TextWriter writer, CultureInfo culture, ICompetitionContext context)
{
var distanceCombinations = await(from dc in context.DistanceCombinations
where dc.CompetitionId == competition.Id
let competitors = from dcc in dc.Competitors
where dcc.Status == DistanceCombinationCompetitorStatus.Confirmed
select dcc.Competitor
select new
{
dc.Number,
dc.Name,
dc.Competition.Starts,
Competitors = competitors.OfType <PersonCompetitor>(),
dc.Distances
}).ToListAsync();
var groups = new XElement("groups");
foreach (var distanceCombination in distanceCombinations.OrderBy(dc => dc.Number))
{
var group = new XElement("group", new XAttribute("name", $"{distanceCombination.Number:00}. {distanceCombination.Name}"), new XElement("competitors", from c in distanceCombination.Competitors.OrderBy(c => c.StartNumber)
select new XElement("competitor", new XAttribute("no", c.StartNumber), new XAttribute("driverregistration", c.LicenseKey), new XAttribute("registration", c.LicenseKey), new XAttribute("class", c.Category), new XAttribute("firstname", c.Name.FirstName ?? ""), new XAttribute("lastname", c.Name.PrefixedSurname ?? ""), new XAttribute("transponders", string.Join(", ", new[] { c.Transponder1, c.Transponder2 }.Where(t => !string.IsNullOrWhiteSpace(t)))), new XAttribute("additional1", c.NationalityCode), new XAttribute("additional2", c.Sponsor ?? ""), new XAttribute("additional3", c.ShortName), new XAttribute("additional4", c.From ?? ""), new XAttribute("additional5", c.ClubFullName ?? ""))));
var runs = new XElement("runs");
foreach (var distance in distanceCombination.Distances.OrderBy(d => d.Number))
{
var calculator = distanceCalculatorManager.Get(distance.Discipline);
var starts = distance.Starts ?? distanceCombination.Starts;
var minimumLapTime = calculator.MininumLapTime(distance);
for (var round = 1; round <= distance.Rounds; round++)
{
var heatCount = calculator.HeatsInRound(distance, round);
for (var heat = 1; heat <= heatCount; heat++)
{
var run = new XElement("run", new XAttribute("name", $"{distance.Number:00}. {calculator.DistanceHeatName(distance, round, heat, heatCount, culture)}"), new XAttribute("shortname", calculator.HeatName(distance, round, heat, culture)), new XAttribute("date", starts.ToString("yyyy-MM-dd")), new XAttribute("time", starts.ToString("HH:mm:ss")), new XAttribute("type", "race"), new XAttribute("countfirst", "lap"), new XAttribute("minimumlaptime", minimumLapTime.ToString(@"h\:mm\:ss\.fff")));
switch (calculator.HeatStartEvent)
{
case HeatStartEvent.Start:
run.Add(new XAttribute("startmethod", "flag"));
break;
case HeatStartEvent.FirstPassing:
run.Add(new XAttribute("startmethod", "firstpassing"));
break;
}
switch (distance.ValueQuantity)
{
case DistanceValueQuantity.Length:
case DistanceValueQuantity.Count:
run.Add(new XAttribute("autofinishmethod", "individualonlaps"));
run.Add(new XAttribute("autofinishlaps", calculator.Laps(distance)));
break;
}
runs.Add(run);
}
starts += calculator.EstimatedRoundDuration(distance, round);
}
}
@group.Add(runs);
groups.Add(@group);
}
var document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"), groups);
document.Save(writer);
}
public DistanceCombinationsWorkflow(ICompetitionContext context, IEventRecorder recorder)
{
this.context = context;
this.recorder = recorder;
}
public CompetitionSecurityWorkflow(ICompetitionContext context)
{
this.context = context;
userSecurityWorkflow = new UserSecurityWorkflow(context);
}
