Example #1
0
 private void PopulateWeather(RaceDto race, Db.Race dbRace)
 {
     if (dbRace.Weather == null)
     {
         var dbObj = _mapper.Map<Database.Entities.Weather>(race.Weather);
         dbRace.Weather = dbObj;
     }
     else
     {
         var id = dbRace.Weather.Id;
         var createdDate = dbRace.Weather.CreatedDate;
         _mapper.Map<WeatherDto, Database.Entities.Weather>(race.Weather, dbRace.Weather);
         dbRace.Weather.CreatedDate = createdDate;
         dbRace.Weather.Id = id;
     }
 }
Example #2
0
        private async Task<Guid> SaveInternalAsync(RaceDto race)
        {
            var dbRace = new Db.Race
            {
                Id = Guid.NewGuid(),
                ClubId = race.ClubId
            };

            if (race.Id != default)
            {
                dbRace = await _dbContext.Races
                    .Include(r => r.Scores)
                    .Include(r => r.SeriesRaces)
                    .Include(r => r.Weather)
                    .AsSingleQuery()
                    .SingleAsync(r => r.Id == race.Id)
                    .ConfigureAwait(false);
            }
            IEnumerable<Guid> seriesIdsToUpdate =
                dbRace.SeriesRaces?.Select(r => r.SeriesId)?.ToList() ?? new List<Guid>();

            dbRace.Name = race.Name;
            dbRace.Order = race.Order;
            dbRace.Date = race.Date ?? DateTime.Today;
            dbRace.Description = race.Description;
            dbRace.State = race.State;
            dbRace.TrackingUrl = race.TrackingUrl;
            dbRace.UpdatedDate = DateTime.UtcNow;
            dbRace.UpdatedBy = race.UpdatedBy;

            PopulateWeather(race, dbRace);

            dbRace.Fleet = _dbContext.Fleets.SingleOrDefault(f => f.Id == race.FleetId);

            if (race.SeriesIds != null)
            {
                dbRace.SeriesRaces ??= new List<Db.SeriesRace>();
                dbRace.SeriesRaces.Clear();
                foreach (var seriesId in race.SeriesIds)
                {
                    dbRace.SeriesRaces.Add(new Db.SeriesRace
                    {
                        SeriesId = seriesId,
                        RaceId = dbRace.Id
                    });
                }
            }
            if (race.Scores != null)
            {
                dbRace.Scores ??= new List<Db.Score>();

                dbRace.Scores.Clear();
                foreach (var score in race.Scores)
                {
                    var newScore = new Db.Score
                    {
                        Id = Guid.NewGuid(),
                        CompetitorId = score.CompetitorId,
                        Race = dbRace,
                        Place = score.Place,
                        Code = score.Code,
                        CodePoints = score.CodePoints
                    };

                    _dbContext.Scores.Add(newScore);
                }
            }
            if (race.Id == default)
            {
                _dbContext.Races.Add(dbRace);
            }
            else
            {
                _dbContext.Races.Update(dbRace);
            }

            await _dbContext.SaveChangesAsync()
                .ConfigureAwait(false);
            seriesIdsToUpdate = seriesIdsToUpdate.Union(
                dbRace.SeriesRaces?.Select(rs => rs.SeriesId).ToList() ?? new List<Guid>());

            foreach (var seriesId in seriesIdsToUpdate)
            {
                AddUpdateSeriesJob(seriesId, race.UpdatedBy);
            }

            return dbRace.Id;
        }