private void Merge(SportEventSummaryDTO dto, CultureInfo culture)
{
Guard.Argument(dto, nameof(dto)).NotNull();
Guard.Argument(culture, nameof(culture)).NotNull();
lock (MergeLock)
{
Names[culture] = dto.Name;
if (dto.SportId != null)
{
_sportId = dto.SportId;
}
if (dto.Scheduled != null)
{
Scheduled = dto.Scheduled;
}
if (dto.ScheduledEnd != null)
{
ScheduledEnd = dto.ScheduledEnd;
}
if (dto.StartTimeTbd != null)
{
_startTimeTbd = dto.StartTimeTbd;
}
if (dto.ReplacedBy != null)
{
_replacedBy = dto.ReplacedBy;
}
}
}
private static void CheckEventEquality(SportEventSummaryDTO eventSummary, XElement element)
{
Assert.IsNotNull(eventSummary);
Assert.IsNotNull(element);
Assert.AreEqual(eventSummary.Id.ToString(), element.Attribute(XName.Get("id"))?.Value);
string scheduled = element.Attribute(XName.Get("scheduled")) == null
? null
: element.Attribute(XName.Get("scheduled"))?.Value.Substring(0, 10);
Assert.AreEqual(eventSummary.Scheduled?.ToString("yyyy-MM-dd"), scheduled);
var match = eventSummary as MatchDTO;
if (match != null)
{
CompareRound(match.Round, element.Element(GetXName("tournament_round")));
CompareEntity(match.Season, element.Element(GetXName("season")));
CompareTournament(match.Tournament, element.Element(GetXName("tournament")));
var allXmlCompetitors = element.Descendants(GetXName("competitor")).ToList();
Assert.AreEqual(match.Competitors.Count(), allXmlCompetitors.Count);
foreach (var xmlCompetitor in allXmlCompetitors)
{
var xmlId = xmlCompetitor.Attribute(XName.Get("id"))?.Value;
var competitor = match.Competitors.ToList().Find(t => t.Id.ToString() == xmlId);
CompareCompetitor(competitor, xmlCompetitor);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SportEventCI" /> class
/// </summary>
/// <param name="eventSummary">The sport event summary</param>
/// <param name="dataRouterManager">The <see cref="IDataRouterManager" /> used to obtain summary and fixture</param>
/// <param name="semaphorePool">A <see cref="ISemaphorePool" /> instance used to obtain sync objects</param>
/// <param name="currentCulture">A <see cref="CultureInfo" /> of the <see cref="SportEventSummaryDTO" /> instance</param>
/// <param name="defaultCulture">
/// A <see cref="CultureInfo" /> specifying the language used when fetching info which is not
/// translatable (e.g. Scheduled, ..)
/// </param>
/// <param name="fixtureTimestampCache">A <see cref="MemoryCache" /> used to cache the sport events fixture timestamps</param>
public SportEventCI(SportEventSummaryDTO eventSummary,
IDataRouterManager dataRouterManager,
ISemaphorePool semaphorePool,
CultureInfo currentCulture,
CultureInfo defaultCulture,
MemoryCache fixtureTimestampCache)
: this(eventSummary.Id, dataRouterManager, semaphorePool, defaultCulture, fixtureTimestampCache)
{
Contract.Requires(eventSummary != null);
Contract.Requires(currentCulture != null);
Merge(eventSummary, currentCulture);
}
/// <summary>
/// Initializes a new instance of the <see cref="SportEventCI" /> class
/// </summary>
/// <param name="eventSummary">The sport event summary</param>
/// <param name="dataRouterManager">The <see cref="IDataRouterManager"/> used to obtain summary and fixture</param>
/// <param name="semaphorePool">A <see cref="ISemaphorePool" /> instance used to obtain sync objects</param>
/// <param name="currentCulture">A <see cref="CultureInfo" /> of the <see cref="SportEventSummaryDTO" /> instance</param>
/// <param name="defaultCulture">A <see cref="CultureInfo" /> specifying the language used when fetching info which is not translatable (e.g. Scheduled, ..)</param>
/// <param name="fixtureTimestampCache">A <see cref="MemoryCache"/> used to cache the sport events fixture timestamps</param>
public SportEventCI(SportEventSummaryDTO eventSummary,
IDataRouterManager dataRouterManager,
ISemaphorePool semaphorePool,
CultureInfo currentCulture,
CultureInfo defaultCulture,
MemoryCache fixtureTimestampCache)
: this(eventSummary.Id, dataRouterManager, semaphorePool, defaultCulture, fixtureTimestampCache)
{
Guard.Argument(eventSummary, nameof(eventSummary)).NotNull();
Guard.Argument(currentCulture, nameof(currentCulture)).NotNull();
Merge(eventSummary, currentCulture);
}
/// <summary>
/// Builds a <see cref="SportEventCI" /> instance from the provided <see cref="SportEventSummaryDTO" /> instance
/// </summary>
/// <param name="eventSummary">A <see cref="SportEventSummaryDTO" /> instance containing basic sport event info</param>
/// <param name="currentCulture">A <see cref="CultureInfo"/> of the <see cref="SportEventSummaryDTO"/> data</param>
/// <returns>a new instance of <see cref="SportEventCI" /> instance</returns>
public SportEventCI Build(SportEventSummaryDTO eventSummary, CultureInfo currentCulture)
{
if (eventSummary.Id.TypeGroup == ResourceTypeGroup.STAGE)
{
var item = eventSummary as StageDTO;
if (item != null)
{
return(new StageCI(item, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
var tour = eventSummary as TournamentInfoDTO;
if (tour != null)
{
return(new TournamentInfoCI(tour, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
}
if (eventSummary.Id.TypeGroup == ResourceTypeGroup.MATCH)
{
var item = eventSummary as MatchDTO;
if (item != null)
{
return(new MatchCI(item, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
}
if (eventSummary.Id.TypeGroup == ResourceTypeGroup.SEASON ||
eventSummary.Id.TypeGroup == ResourceTypeGroup.BASIC_TOURNAMENT ||
eventSummary.Id.TypeGroup == ResourceTypeGroup.TOURNAMENT)
{
var item = eventSummary as TournamentInfoDTO;
if (item != null)
{
return(new TournamentInfoCI(item, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
}
if (eventSummary.Id.TypeGroup == ResourceTypeGroup.DRAW)
{
var item = eventSummary as DrawDTO;
if (item != null)
{
return(new DrawCI(item, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
}
if (eventSummary.Id.TypeGroup == ResourceTypeGroup.LOTTERY)
{
var item = eventSummary as LotteryDTO;
if (item != null)
{
return(new LotteryCI(item, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
}
return(new SportEventCI(eventSummary, _dataRouterManager, _semaphorePool, currentCulture, _defaultCulture, _fixtureTimestampCache));
}
/// <summary>
/// Merge current instance with the data obtained via provider
/// </summary>
/// <param name="eventSummary">A <see cref="SportEventSummaryDTO" /> used to merge properties with current instance</param>
/// <param name="culture">A language code of the <see cref="SportEventSummaryDTO" /> data</param>
/// <param name="useLock">Should the lock mechanism be used during merge</param>
public void Merge(SportEventSummaryDTO eventSummary, CultureInfo culture, bool useLock)
{
if (useLock)
{
lock (MergeLock)
{
Merge(eventSummary, culture);
}
}
else
{
Merge(eventSummary, culture);
}
}
private void Merge(SportEventSummaryDTO eventSummary, CultureInfo culture)
{
Contract.Requires(eventSummary != null);
Contract.Requires(culture != null);
lock (MergeLock)
{
Names[culture] = eventSummary.Name;
_sportId = eventSummary.SportId;
_scheduled = eventSummary.Scheduled;
_scheduledEnd = eventSummary.ScheduledEnd;
_startTimeTbd = eventSummary.StartTimeTbd;
_replacedBy = eventSummary.ReplacedBy;
}
}
private void Merge(SportEventSummaryDTO eventSummary, CultureInfo culture)
{
Guard.Argument(eventSummary, nameof(eventSummary)).NotNull();
Guard.Argument(culture, nameof(culture)).NotNull();
lock (MergeLock)
{
Names[culture] = eventSummary.Name;
_sportId = eventSummary.SportId;
Scheduled = eventSummary.Scheduled;
ScheduledEnd = eventSummary.ScheduledEnd;
_startTimeTbd = eventSummary.StartTimeTbd;
_replacedBy = eventSummary.ReplacedBy;
}
}
private void AddSportEvent(URN id, SportEventSummaryDTO item, CultureInfo culture, ISportEventCI requester, DtoType dtoType)
{
TournamentInfoDTO tournamentInfoDTO = null;
lock (_addLock)
{
try
{
var cacheItem = _sportEventCacheItemFactory.Get(Cache.Get(id.ToString()));
if (requester != null && !Equals(requester, cacheItem) && id.Equals(requester.Id))
{
try
{
var requesterMerged = false;
var fixture = item as FixtureDTO;
if (fixture != null)
{
if (requester.Id.TypeGroup == ResourceTypeGroup.MATCH)
{
((MatchCI)requester).MergeFixture(fixture, culture, true);
}
else if (requester.Id.TypeGroup == ResourceTypeGroup.STAGE)
{
((StageCI)requester).MergeFixture(fixture, culture, true);
}
else
{
((TournamentInfoCI)requester).MergeFixture(fixture, culture, true);
}
requesterMerged = true;
}
if (!requesterMerged)
{
var match = item as MatchDTO;
if (match != null)
{
((MatchCI)requester).Merge(match, culture, true);
requesterMerged = true;
}
}
if (!requesterMerged)
{
var stage = item as StageDTO;
if (stage != null)
{
((StageCI)requester).Merge(stage, culture, true);
requesterMerged = true;
}
}
if (!requesterMerged)
{
var tour = item as TournamentInfoDTO;
if (tour != null)
{
var stageCI = requester as StageCI;
if (stageCI != null)
{
stageCI.Merge(tour, culture, true);
requesterMerged = true;
}
else
{
var tourCI = requester as TournamentInfoCI;
if (tourCI != null)
{
tourCI.Merge(tour, culture, true);
requesterMerged = true;
}
}
}
}
if (!requesterMerged)
{
var draw = item as DrawDTO;
if (draw != null)
{
((DrawCI)requester).Merge(draw, culture, true);
requesterMerged = true;
}
}
if (!requesterMerged)
{
var lottery = item as LotteryDTO;
if (lottery != null)
{
((LotteryCI)requester).Merge(lottery, culture, true);
requesterMerged = true;
}
}
if (!requesterMerged)
{
requester.Merge(item, culture, true);
}
}
catch (Exception)
{
ExecutionLog.Debug($"Merging failed for {id} and item type: {item.GetType().Name} and dto type: {dtoType} for requester: {requester.Id}.");
}
}
if (cacheItem != null)
{
//ExecutionLog.Debug($"Saving OLD data for {id} and item type: {item.GetType().Name} and dto type: {dtoType}.");
var merged = false;
//var cacheItem = _sportEventCacheItemFactory.Get(Cache.Get(id.ToString()));
var fixture = item as FixtureDTO;
if (fixture != null)
{
if (cacheItem.Id.TypeGroup == ResourceTypeGroup.MATCH)
{
((MatchCI)cacheItem).MergeFixture(fixture, culture, true);
}
else if (cacheItem.Id.TypeGroup == ResourceTypeGroup.STAGE)
{
((StageCI)cacheItem).MergeFixture(fixture, culture, true);
}
else
{
((TournamentInfoCI)cacheItem).MergeFixture(fixture, culture, true);
}
if (fixture.Tournament != null)
{
tournamentInfoDTO = new TournamentInfoDTO(fixture.Tournament);
}
merged = true;
}
if (!merged)
{
var stage = item as StageDTO;
if (stage != null)
{
((StageCI)cacheItem).Merge(stage, culture, true);
merged = true;
if (stage.Tournament != null)
{
tournamentInfoDTO = new TournamentInfoDTO(stage.Tournament);
}
}
}
if (!merged)
{
var tour = item as TournamentInfoDTO;
if (tour != null)
{
var stageCI = cacheItem as StageCI;
if (stageCI != null)
{
stageCI.Merge(tour, culture, true);
merged = true;
}
else
{
var tourCI = cacheItem as TournamentInfoCI;
if (tourCI != null)
{
tourCI.Merge(tour, culture, true);
merged = true;
}
}
}
}
if (!merged)
{
var match = item as MatchDTO;
if (match != null)
{
((MatchCI)cacheItem).Merge(match, culture, true);
merged = true;
if (match.Tournament != null)
{
tournamentInfoDTO = new TournamentInfoDTO(match.Tournament);
}
}
}
if (!merged)
{
var draw = item as DrawDTO;
if (draw != null)
{
((DrawCI)cacheItem).Merge(draw, culture, true);
merged = true;
}
}
if (!merged)
{
var lottery = item as LotteryDTO;
if (lottery != null)
{
((LotteryCI)cacheItem).Merge(lottery, culture, true);
merged = true;
}
}
if (!merged)
{
cacheItem.Merge(item, culture, true);
}
}
else
{
//ExecutionLog.Debug($"Saving NEW data for {id} and item type: {item.GetType().Name} and dto type: {dtoType}.");
var ci = _sportEventCacheItemFactory.Build(item, culture);
if (dtoType == DtoType.SportEventSummary || dtoType == DtoType.LotteryDraw || dtoType == DtoType.MatchSummary)
{
ci.LoadedSummaries.Add(culture);
}
else if (dtoType == DtoType.Fixture)
{
ci.LoadedFixtures.Add(culture);
}
AddNewCacheItem(ci);
if (!ci.Id.Equals(id))
{
var tInfo = item as TournamentInfoDTO;
if (tInfo != null)
{
var newTournamentDto = new TournamentInfoDTO(tInfo, tInfo.Season != null, tInfo.CurrentSeason != null);
var ci2 = _sportEventCacheItemFactory.Build(newTournamentDto, culture);
AddNewCacheItem(ci2);
}
else
{
var ci2 = _sportEventCacheItemFactory.Build(item, culture);
ci2.Id = id;
AddNewCacheItem(ci2);
}
}
}
}
catch (Exception ex)
{
ExecutionLog.Error($"Error adding sport event for id={id}, dto type={item?.GetType().Name} and lang={culture.TwoLetterISOLanguageName}.", ex);
}
}
// if there are events for non-standard tournaments (tournaments not on All tournaments for all sports)
// TODO: should we save/merge all, or just adding non-existing???
if (tournamentInfoDTO != null && (SpecialTournaments.Contains(tournamentInfoDTO.Id) || !Cache.Contains(tournamentInfoDTO.Id.ToString())))
{
if (SpecialTournaments.Contains(tournamentInfoDTO.Id))
{
//ExecutionLog.Debug($"Updating tournament id={tournamentInfoDTO.Id}, introduced by event id={id} and lang=[{culture.TwoLetterISOLanguageName}].");
}
else
{
//ExecutionLog.Debug($"Saving tournament id={tournamentInfoDTO.Id}, introduced by event id={id} and lang=[{culture.TwoLetterISOLanguageName}].");
SpecialTournaments.Add(tournamentInfoDTO.Id);
}
AddSportEvent(tournamentInfoDTO.Id, tournamentInfoDTO, culture, null, dtoType);
}
}
private void AddDataFromSportEventSummary(SportEventSummaryDTO dto, CultureInfo culture)
{
var match = dto as MatchDTO;
if (match?.Tournament != null)
{
AddSport(match.SportId, match.Tournament.Sport, culture);
AddCategory(match.Tournament.Category.Id, match.Tournament.Category, match.SportId, new List <URN> {
match.Tournament.Id
}, culture);
return;
}
var tour = dto as TournamentInfoDTO;
if (tour != null)
{
AddSport(tour.SportId, tour.Sport, culture);
AddCategory(tour.Category.Id, tour.Category, tour.SportId, new List <URN> {
tour.Id
}, culture);
if (tour.TournamentInfo != null)
{
AddDataFromSportEventSummary(tour.TournamentInfo, culture);
}
return;
}
var stage = dto as StageDTO;
if (stage?.Tournament != null)
{
if (stage.Tournament?.Sport != null)
{
AddSport(stage.Tournament.Sport.Id, stage.Tournament.Sport, culture);
}
if (stage.Tournament.Category != null)
{
AddCategory(stage.Tournament.Category.Id, stage.Tournament.Category, stage.SportId, new List <URN> {
stage.Id
}, culture);
}
return;
}
var draw = dto as DrawDTO;
if (draw != null)
{
if (draw.Lottery != null)
{
AddSport(draw.Lottery.Sport.Id, draw.Lottery.Sport, culture);
AddCategory(draw.Lottery.Category.Id, draw.Lottery.Category, draw.SportId, null, culture);
}
return;
}
var lottery = dto as LotteryDTO;
if (lottery != null)
{
AddSport(lottery.Sport.Id, lottery.Sport, culture);
AddCategory(lottery.Category.Id, lottery.Category, lottery.SportId ?? lottery.Sport?.Id, null, culture);
// ReSharper disable once RedundantJumpStatement
return;
}
}
