Exemple #1
0
        public async Task <ICollection <RaceTransponder> > LoadFromStreamAsync(Guid competitionId, Guid distanceId, Stream stream)
        {
            using (var context = contextFactory())
                using (var transaction = context.BeginTransaction(IsolationLevel.RepeatableRead))
                    using (var reader = new StreamReader(stream, Encoding))
                        try
                        {
                            var transponders = await context.Transponders.ToListAsync();

                            var races = await(from r in context.Races
                                              where r.Distance.CompetitionId == competitionId && r.DistanceId == distanceId
                                              select new
                            {
                                r.Id,
                                r.Lane,
                                r.Competitor,
                                Existing = r.Transponders
                            }).ToListAsync();
                            var raceTransponders = new List <RaceTransponder>();

                            var    i = 0;
                            string line;
                            while ((line = reader.ReadLine()) != null)
                            {
                                i++;

                                var parts = line.Split(',', ';', '\t');
                                if (parts.Length < 2)
                                {
                                    throw new FormatException(string.Format(Resources.TooFewFields, 2, i));
                                }

                                int lane;
                                if (!int.TryParse(parts[0], out lane))
                                {
                                    throw new FormatException(string.Format(Resources.InvalidLane, parts[0], i));
                                }

                                int startNumber;
                                if (!int.TryParse(parts[1], out startNumber))
                                {
                                    throw new FormatException(string.Format(Resources.InvalidStartNumber, parts[1], i));
                                }

                                var race = races.SingleOrDefault(r => r.Competitor.StartNumber == startNumber && r.Lane == lane);
                                if (race == null)
                                {
                                    throw new FormatException(string.Format(Resources.RaceNotFound, startNumber, lane, i));
                                }

                                var competitor = race.Competitor as PersonCompetitor;
                                if (competitor == null)
                                {
                                    throw new FormatException(string.Format(Resources.InvalidCompetitorClass, i));
                                }

                                foreach (var existing in race.Existing)
                                {
                                    context.RaceTransponders.Remove(existing);
                                }
                                await context.SaveChangesAsync();

                                foreach (var label in parts.Skip(2))
                                {
                                    long code;
                                    if (!transponderCodeConverter.TryConvertLabel(TransponderType, label, out code))
                                    {
                                        throw new FormatException(string.Format(Resources.InvalidTransponderLabel, label, TransponderType, i));
                                    }

                                    var transponder = transponders.SingleOrDefault(t => t.Type == TransponderType && t.Code == code);
                                    if (transponder == null)
                                    {
                                        transponder = new Transponder
                                        {
                                            Type  = TransponderType,
                                            Code  = code,
                                            Label = label
                                        };
                                        context.Transponders.Add(transponder);
                                        transponders.Add(transponder);
                                    }

                                    var raceTransponder = new RaceTransponder
                                    {
                                        Transponder = transponder,
                                        PersonId    = competitor.PersonId,
                                        RaceId      = race.Id
                                    };
                                    raceTransponders.Add(raceTransponder);

                                    context.RaceTransponders.Add(raceTransponder);
                                    await context.SaveChangesAsync();
                                }
                            }

                            transaction.Commit();
                            return(raceTransponders);
                        }
                        catch (Exception)
                        {
                            transaction.Rollback();
                            throw;
                        }
        }
Exemple #2
0
        public static IEnumerable <RaceTransponder> ReadRaceTransponders(TextReader reader, ICollection <Race> races, ICollection <Transponder> transponders, bool reversePeople)
        {
            reader.ReadLine();

            while (true)
            {
                string labelLine;
                do
                {
                    labelLine = reader.ReadLine();
                    if (labelLine == null)
                    {
                        yield break;
                    }
                } while (labelLine.StartsWith("#"));

                int startNumber = int.Parse(labelLine.Substring(0, 3), NumberStyles.None);
                if (startNumber == 0)
                {
                    continue;
                }

                foreach (var race in races.Where(r => r.Competitor.StartNumber == startNumber))
                {
                    IList <Guid> personIds;
                    var          personCompetitor = race.Competitor as PersonCompetitor;
                    if (personCompetitor != null)
                    {
                        personIds = new[] { personCompetitor.PersonId }
                    }
                    ;
                    else
                    {
                        var teamCompetitor = race.Competitor as TeamCompetitor;
                        if (teamCompetitor != null && teamCompetitor.Members != null)
                        {
                            personIds = reversePeople
                                ? teamCompetitor.Members.OrderByDescending(m => m.Order).Select(m => m.Member.PersonId).ToList()
                                : teamCompetitor.Members.OrderBy(m => m.Order).Select(m => m.Member.PersonId).ToList();
                        }
                        else
                        {
                            personIds = new Guid[0];
                        }
                    }

                    if (race.Transponders == null)
                    {
                        race.Transponders = new Collection <RaceTransponder>();
                    }

                    int i = 13;
                    while (labelLine.Length >= i + 8)
                    {
                        string label = labelLine.Substring(i, 8);
                        i += 10;

                        var transponder = transponders.SingleOrDefault(t => t.Label == label);
                        if (transponder == null)
                        {
                            continue;
                        }

                        var raceTransponder = new RaceTransponder
                        {
                            RaceId      = race.Id,
                            Race        = race,
                            PersonId    = personIds.ElementAtOrDefault(race.Transponders.Count / 2),
                            Type        = transponder.Type,
                            Code        = transponder.Code,
                            Transponder = transponder
                        };

                        race.Transponders.Add(raceTransponder);

                        yield return(raceTransponder);
                    }
                }
            }
        }
Exemple #3
0
 public RaceTransponderViewModel(RaceTransponder transponder)
 {
     this.transponder = transponder;
 }