/// <summary>
/// Merges the specified dto
/// </summary>
/// <param name="dto">The dto</param>
/// <param name="culture">The culture</param>
public void Merge(TournamentInfoDTO dto, CultureInfo culture)
{
base.Merge(new CacheItem(dto.Id, dto.Name, culture), culture);
if (dto.Category != null)
{
if (!Category.Equals(dto.Category.Id))
{
// WRONG
}
}
if (dto.CurrentSeason != null)
{
if (CurrentSeason == null)
{
CurrentSeason = new CurrentSeasonInfoCI(dto.CurrentSeason, culture, _dataRouterManager);
}
else
{
CurrentSeason.Merge(dto.CurrentSeason, culture);
}
}
}
public void MergeTournamentGroupRemoveName()
{
// set group name
_tourApiData.groups[0].name = "Name1";
_tourDtoData = new TournamentInfoDTO(_tourApiData);
_tourCiData.Merge(_tourDtoData, TestData.Culture, false);
_tourCiData.LoadedSummaries.Add(TestData.Culture);
VerifyTournamentGroups(_tourApiData.groups, _tourCiData.GetGroupsAsync(_cultures).Result);
VerifyTournamentCompetitors(_tourApiData.competitors, _tourApiData.groups, _tourCiData.GetCompetitorsIdsAsync(_cultures).Result);
// change group name
_tourApiData.groups[0].name = null;
_tourDtoData = new TournamentInfoDTO(_tourApiData);
_tourCiData.Merge(_tourDtoData, TestData.Culture, false);
VerifyTournamentGroups(_tourApiData.groups, _tourCiData.GetGroupsAsync(_cultures).Result);
VerifyTournamentCompetitors(_tourApiData.competitors, _tourApiData.groups, _tourCiData.GetCompetitorsIdsAsync(_cultures).Result);
// remove group
_tourApiData.groups = null;
_tourDtoData = new TournamentInfoDTO(_tourApiData);
_tourCiData.Merge(_tourDtoData, TestData.Culture, false);
VerifyTournamentGroups(_tourApiData.groups, _tourCiData.GetGroupsAsync(_cultures).Result);
VerifyTournamentCompetitors(_tourApiData.competitors, _tourApiData.groups, _tourCiData.GetCompetitorsIdsAsync(_cultures).Result);
}
/// <summary>
/// Merges the specified dto
/// </summary>
/// <param name="dto">The dto</param>
/// <param name="culture">The culture</param>
private void ActualMerge(TournamentInfoDTO dto, CultureInfo culture)
{
base.Merge(dto, culture, false);
if (dto.Category != null)
{
_categoryId = dto.Category.Id;
}
if (dto.TournamentCoverage != null)
{
_tournamentCoverage = new TournamentCoverageCI(dto.TournamentCoverage);
}
if (dto.Competitors != null)
{
if (_competitors == null)
{
_competitors = new List <CompetitorCI>(dto.Competitors.Select(t => new CompetitorCI(t, culture, DataRouterManager)));
}
else
{
MergeCompetitors(dto.Competitors, culture);
}
FillCompetitorsReferences(dto.Competitors);
}
if (dto.CurrentSeason != null)
{
if (_currentSeasonInfo == null)
{
_currentSeasonInfo = new CurrentSeasonInfoCI(dto.CurrentSeason, culture, DataRouterManager);
}
else
{
_currentSeasonInfo.Merge(dto.CurrentSeason, culture);
}
}
if (dto.Groups != null)
{
if (_groups == null)
{
_groups = new List <GroupCI>(dto.Groups.Select(s => new GroupCI(s, culture, DataRouterManager)));
}
else
{
MergeGroups(dto.Groups, culture);
}
var comps = new List <CompetitorDTO>();
foreach (var groupDTO in dto.Groups)
{
comps.AddRange(groupDTO.Competitors);
}
FillCompetitorsReferences(comps);
}
if (dto.Schedule != null)
{
_scheduleUrns = new ReadOnlyCollection <URN>(dto.Schedule.Select(s => s.Id).ToList());
}
if (dto.CurrentRound != null)
{
if (_round == null)
{
_round = new RoundCI(dto.CurrentRound, culture);
}
else
{
_round.Merge(dto.CurrentRound, culture);
}
}
if (!string.IsNullOrEmpty(dto.Year))
{
_year = dto.Year;
}
if (dto.TournamentInfo != null)
{
if (_tournamentInfoBasic == null)
{
_tournamentInfoBasic = new TournamentInfoBasicCI(dto.TournamentInfo, culture, DataRouterManager);
}
else
{
_tournamentInfoBasic.Merge(dto.TournamentInfo, culture);
}
}
if (dto.SeasonCoverage != null)
{
_seasonCoverage = new SeasonCoverageCI(dto.SeasonCoverage);
}
if (dto.ExhibitionGames != null)
{
_exhibitionGames = dto.ExhibitionGames;
}
}
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);
}
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be add</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the cache item</param>
/// <param name="requester">The cache item which invoked request</param>
/// <returns><c>true</c> if is added/updated, <c>false</c> otherwise</returns>
/// <exception cref="NotImplementedException"></exception>
protected override bool CacheAddDtoItem(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
if (_isDisposed)
{
return(false);
}
var saved = false;
switch (dtoType)
{
case DtoType.Category:
break;
case DtoType.Competitor:
break;
case DtoType.CompetitorProfile:
break;
case DtoType.SimpleTeamProfile:
break;
case DtoType.Fixture:
var fixture = item as FixtureDTO;
if (fixture != null)
{
AddSportEvent(id, fixture, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(FixtureDTO), item.GetType());
}
break;
case DtoType.MarketDescription:
break;
case DtoType.MatchSummary:
var match = item as MatchDTO;
if (match != null)
{
AddSportEvent(id, match, culture, requester, dtoType);
if (match.Tournament != null)
{
var ti = new TournamentInfoDTO(match.Tournament);
AddSportEvent(ti.Id, ti, culture, requester, dtoType);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchDTO), item.GetType());
}
break;
case DtoType.MatchTimeline:
var timeline = item as MatchTimelineDTO;
if (timeline != null)
{
AddMatchTimeLine(timeline, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchTimelineDTO), item.GetType());
}
break;
case DtoType.PlayerProfile:
break;
case DtoType.RaceSummary:
var stage = item as StageDTO;
if (stage != null)
{
AddSportEvent(id, stage, culture, requester, dtoType);
if (stage.Tournament != null)
{
var ti = new TournamentInfoDTO(stage.Tournament);
AddSportEvent(ti.Id, ti, culture, requester, dtoType);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(StageDTO), item.GetType());
}
break;
case DtoType.Sport:
var sport = item as SportDTO;
if (sport != null)
{
SaveTournamentDataFromSport(sport, culture);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportDTO), item.GetType());
}
break;
case DtoType.SportList:
var sportEntityList = item as EntityList <SportDTO>;
if (sportEntityList != null)
{
foreach (var sportDTO in sportEntityList.Items)
{
SaveTournamentDataFromSport(sportDTO, culture);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <SportDTO>), item.GetType());
}
break;
case DtoType.SportEventStatus:
break;
case DtoType.SportEventSummary:
var tourInfo = item as TournamentInfoDTO;
if (tourInfo != null)
{
SaveTournamentDataToSportEventCache(tourInfo, tourInfo.CurrentSeason?.Id, culture);
if (tourInfo.Season != null)
{
SaveTournamentDataToSportEventCache(tourInfo, tourInfo.Season?.Id, culture);
}
break;
}
var summary = item as SportEventSummaryDTO;
if (summary != null)
{
AddSportEvent(id, summary, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportEventSummaryDTO), item.GetType());
}
break;
case DtoType.SportEventSummaryList:
var summaryList = item as EntityList <SportEventSummaryDTO>;
if (summaryList != null)
{
foreach (var s in summaryList.Items)
{
var tourInfosDTO = s as TournamentInfoDTO;
if (tourInfosDTO != null)
{
SaveTournamentDataToSportEventCache(tourInfosDTO, tourInfosDTO.CurrentSeason?.Id, culture);
if (tourInfosDTO.Season != null)
{
SaveTournamentDataToSportEventCache(tourInfosDTO, tourInfosDTO.Season?.Id, culture);
}
continue;
}
AddSportEvent(s.Id, s, culture, requester, dtoType);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <SportEventSummaryDTO>), item.GetType());
}
break;
case DtoType.Tournament:
var t = item as TournamentDTO;
if (t != null)
{
var ti = new TournamentInfoDTO(t);
AddSportEvent(id, ti, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentDTO), item.GetType());
}
break;
case DtoType.TournamentInfo:
var tour = item as TournamentInfoDTO;
if (tour != null)
{
AddSportEvent(id, tour, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.TournamentSeasons:
var tourSeasons = item as TournamentSeasonsDTO;
if (tourSeasons?.Tournament != null)
{
AddSportEvent(id, tourSeasons.Tournament, culture, requester, dtoType);
var cacheItem = (TournamentInfoCI)_sportEventCacheItemFactory.Get(Cache.Get(id.ToString()));
cacheItem.Merge(tourSeasons, culture, true);
if (tourSeasons.Seasons != null && tourSeasons.Seasons.Any())
{
foreach (var season in tourSeasons.Seasons)
{
AddSportEvent(season.Id, new TournamentInfoDTO(season), culture, null, dtoType);
}
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.MarketDescriptionList:
break;
case DtoType.VariantDescription:
break;
case DtoType.VariantDescriptionList:
break;
case DtoType.Lottery:
var lottery = item as LotteryDTO;
if (lottery != null)
{
AddSportEvent(id, lottery, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.LotteryDraw:
var draw = item as DrawDTO;
if (draw != null)
{
AddSportEvent(id, draw, culture, requester, dtoType);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.LotteryList:
var lotteryList = item as EntityList <LotteryDTO>;
if (lotteryList != null && lotteryList.Items.Any())
{
foreach (var l in lotteryList.Items)
{
AddSportEvent(l.Id, l, culture, requester, dtoType);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.BookingStatus:
if (Cache.Contains(id.ToString()))
{
var e = Cache.Get(id.ToString());
var comp = e as CompetitionCI;
comp?.Book();
}
break;
case DtoType.SportCategories:
break;
default:
ExecutionLog.Warn($"Trying to add unchecked dto type:{dtoType} for id: {id}.");
break;
}
return(saved);
}
