public Task GetCompetitorAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetCompetitorAsync");
return(SdkInfo.SimpleTeamIdentifier.Equals(id?.Type, StringComparison.InvariantCultureIgnoreCase) ?
GetSimpleTeamProfileAsync(id, culture, requester) :
GetCompetitorProfileAsync(id, culture, requester));
}
public async Task GetSportEventSummaryAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetSportEventSummaryAsync");
var strId = id?.ToString().Replace(":", "_") ?? string.Empty;
var filePath = GetFile($"summary_{strId}.{culture.TwoLetterISOLanguageName}.xml", culture);
if (string.IsNullOrEmpty(filePath) && id?.TypeGroup != ResourceTypeGroup.BASIC_TOURNAMENT && id?.TypeGroup != ResourceTypeGroup.TOURNAMENT && id?.TypeGroup != ResourceTypeGroup.SEASON)
{
filePath = GetFile(MatchDetailsXml, culture);
}
await ExecuteDelayAsync(id, culture).ConfigureAwait(false);
if (string.IsNullOrEmpty(filePath))
{
Debug.WriteLine($"GetSportEventSummaryAsync for {id} and {culture.TwoLetterISOLanguageName}: no result.");
return;
}
var mapper = new SportEventSummaryMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(_restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await LogSaveDtoAsync(id, result, culture, DtoType.SportEventSummary, requester).ConfigureAwait(false);
}
}
private async Task GetCompetitorProfileAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
Debug.Print($"DRM-GetCompetitorProfileAsync for {id} and culture {culture.TwoLetterISOLanguageName} - START");
var filePath = GetFile($"{culture.TwoLetterISOLanguageName}.competitor.{id?.Id ?? 1}.xml", culture);
CompetitorProfileDTO dto = null;
await ExecuteDelayAsync(id, culture).ConfigureAwait(false);
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
{
//filePath = GetFile(CompetitorProfileXml, culture);
dto = new CompetitorProfileDTO(MessageFactoryRest.GetCompetitorProfileEndpoint(id == null ? 1 : (int)id.Id, StaticRandom.I(15)));
}
else
{
var restDeserializer = new Deserializer <competitorProfileEndpoint>();
var mapper = new CompetitorProfileMapperFactory();
var stream = FileHelper.OpenFile(filePath);
dto = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
}
if (dto != null)
{
await LogSaveDtoAsync(id, dto, culture, DtoType.CompetitorProfile, requester).ConfigureAwait(false);
}
Debug.Print($"DRM-GetCompetitorProfileAsync for {id} and culture {culture.TwoLetterISOLanguageName} - END");
}
public Task GetCompetitorAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetCompetitorAsync");
return(id.IsSimpleTeam()
? GetSimpleTeamProfileAsync(id, culture, requester)
: GetCompetitorProfileAsync(id, culture, requester));
}
public Task <bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType,
ISportEventCI requester)
{
Contract.Requires(id != null);
Contract.Requires(item != null);
return(Contract.Result <Task <bool> >());
}
public async Task GetDrawFixtureAsync(URN drawId, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetDrawFixtureAsync");
var filePath = GetFile("draw_fixture.{culture}.xml", culture);
var restDeserializer = new Deserializer <draw_fixtures>();
var mapper = new DrawFixtureMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(result.Id, result, culture, DtoType.LotteryDraw, requester).ConfigureAwait(false);
}
}
/// <summary>
/// Adds the item to the all registered caches
/// </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 dto 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>
public async Task SaveDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType,
ISportEventCI requester)
{
Contract.Requires(id != null);
Contract.Requires(item != null);
Contract.Requires(culture != null);
if (_caches == null || !_caches.Any())
{
return;
}
//ExecLog.Debug($"Dispatching {id} of type:{dtoType} and lang:[{culture.TwoLetterISOLanguageName}].");
var appropriateCaches = _caches.Where(s => s.Value.RegisteredDtoTypes.Contains(dtoType)).ToList();
//ExecLog.Debug($"Dispatching {id} of type:{dtoType} and lang:[{culture.TwoLetterISOLanguageName}] to {appropriateCaches.Count}/{_caches.Count} caches.");
if (!appropriateCaches.Any())
{
ExecLog.Warn(
$"No cache with registered type:{dtoType} and lang:[{culture.TwoLetterISOLanguageName}] to save data.");
return;
}
var tasks = appropriateCaches.Select(c => c.Value.CacheAddDtoAsync(id, item, culture, dtoType, requester))
.ToArray();
if (tasks.Any())
{
try
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception e)
{
ExecLog.Error(
$"Error saving dto data for id={id}, lang=[{culture.TwoLetterISOLanguageName}], type={dtoType}.",
e);
}
}
else
{
ExecLog.Warn("Cannot save data. There is no registered cache.");
}
//ExecLog.Debug($"Dispatching {id} of type:{dtoType} and lang:[{culture.TwoLetterISOLanguageName}] COMPLETED.");
}
private void AddMatchTimeLine(MatchTimelineDTO item, CultureInfo culture, ISportEventCI requester, DtoType dtoType)
{
AddSportEvent(item.SportEvent.Id, item.SportEvent, culture, requester, dtoType);
lock (_addLock)
{
try
{
UpdateMatchWithTimeline(item, culture);
}
catch (Exception ex)
{
ExecutionLog.Error($"Error adding timeline for id={item.SportEvent.Id}, dto type={item.GetType().Name} and lang={culture.TwoLetterISOLanguageName}.", ex);
}
}
}
public async Task GetDrawSummaryAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetDrawSummaryAsync");
var filePath = GetFile("draw_summary.{culture}.xml", culture);
var restDeserializer = new Deserializer <draw_summary>();
var mapper = new DrawSummaryMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
await ExecuteDelayAsync(id, culture).ConfigureAwait(false);
if (result != null)
{
await LogSaveDtoAsync(result.Id, result, culture, DtoType.LotteryDraw, requester).ConfigureAwait(false);
}
}
private async Task GetSimpleTeamProfileAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
var filePath = GetFile($"{culture.TwoLetterISOLanguageName}.simpleteam.{id?.Id ?? 1}.xml", culture);
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
{
filePath = GetFile(SimpleTeamProfileXml, culture);
}
var restDeserializer = new Deserializer <simpleTeamProfileEndpoint>();
var mapper = new SimpleTeamProfileMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.SimpleTeamProfile, requester).ConfigureAwait(false);
}
}
public async Task GetPlayerProfileAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetPlayerProfileAsync");
var filePath = GetFile($"{culture.TwoLetterISOLanguageName}.player.{id?.Id ?? 1}.xml", culture);
if (string.IsNullOrEmpty(filePath))
{
filePath = GetFile(PlayerProfileXml, culture);
}
var restDeserializer = new Deserializer <playerProfileEndpoint>();
var mapper = new PlayerProfileMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.PlayerProfile, requester).ConfigureAwait(false);
}
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
public Task <bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType,
ISportEventCI requester)
{
var timer = Metric.Context($"AddDtoTo_{CacheName}").Timer($"{dtoType}", Unit.Calls);
using (timer.NewContext($"{id} [{culture.TwoLetterISOLanguageName}]"))
{
//WriteLog($"{CacheName} ::> Saving DTO for id:{id}, lang:[{culture.TwoLetterISOLanguageName}] and type:{dtoType}.");
var syncTask = new Task <bool>(() =>
{
var result = CacheAddDtoItem(id, item, culture, dtoType, requester);
//WriteLog($"{CacheName} ::> Saving DTO for id:{id}, lang:[{culture.TwoLetterISOLanguageName}] and type:{dtoType} COMPLETED.");
return(result);
});
syncTask.Start();
return(syncTask);
}
}
/// <summary> /// Adds the dto item to cache /// </summary> /// <param name="id">The identifier of the object</param> /// <param name="item">The item to be added</param> /// <param name="culture">The culture of the item</param> /// <param name="dtoType">Type of the dto</param> /// <param name="requester">The cache item which invoked request</param> /// <returns><c>true</c> if added, <c>false</c> otherwise</returns> protected abstract bool CacheAddDtoItem(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester);
/// <summary>
/// Adds the dto item to cache
/// </summary>
/// <param name="id">The identifier of the object</param>
/// <param name="item">The item</param>
/// <param name="culture">The culture</param>
/// <param name="dtoType">Type of the dto</param>
/// <param name="requester">The cache item which invoked request</param>
/// <returns><c>true</c> if added, <c>false</c> otherwise</returns>
protected override bool CacheAddDtoItem(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
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 fixtureDTO = item as FixtureDTO;
if (fixtureDTO != null)
{
if (fixtureDTO.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, fixtureDTO.SportEventStatus), fixtureDTO.StatusOnEvent, "Fixture");
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(FixtureDTO), item.GetType());
}
break;
case DtoType.MarketDescription:
break;
case DtoType.MatchSummary:
var matchDTO = item as MatchDTO;
if (matchDTO != null)
{
if (matchDTO.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, matchDTO.SportEventStatus), matchDTO.StatusOnEvent, "Match");
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchDTO), item.GetType());
}
break;
case DtoType.MatchTimeline:
var matchTimelineDTO = item as MatchTimelineDTO;
if (matchTimelineDTO != null)
{
if (matchTimelineDTO.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, matchTimelineDTO.SportEventStatus), matchTimelineDTO.SportEvent.StatusOnEvent, "MatchTimeline");
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchTimelineDTO), item.GetType());
}
break;
case DtoType.PlayerProfile:
break;
case DtoType.RaceSummary:
var stageDTO = item as StageDTO;
if (stageDTO != null)
{
if (stageDTO.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, stageDTO.SportEventStatus), stageDTO.StatusOnEvent, "Stage");
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(StageDTO), item.GetType());
}
break;
case DtoType.Sport:
break;
case DtoType.SportList:
break;
case DtoType.SportEventStatus:
var sportEventStatusDTO = item as SportEventStatusDTO;
if (sportEventStatusDTO != null)
{
AddSportEventStatus(id, new SportEventStatusCI(sportEventStatusDTO, null), sportEventStatusDTO.Status.ToString(), "OddsChange");
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportEventStatusDTO), item.GetType());
}
break;
case DtoType.SportEventSummary:
var competitionDTO = item as CompetitionDTO;
if (competitionDTO != null)
{
if (competitionDTO.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, competitionDTO.SportEventStatus), competitionDTO.StatusOnEvent, "SportEventSummary");
}
saved = true;
}
break;
case DtoType.SportEventSummaryList:
var summaryList = item as EntityList <SportEventSummaryDTO>;
if (summaryList != null)
{
foreach (var s in summaryList.Items)
{
var compDTO = s as CompetitionDTO;
if (compDTO?.SportEventStatus != null)
{
AddSportEventStatus(id, new SportEventStatusCI(null, compDTO.SportEventStatus), s.StatusOnEvent, "SportEventSummaryList");
}
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <SportEventSummaryDTO>), item.GetType());
}
break;
case DtoType.Tournament:
break;
case DtoType.TournamentInfo:
break;
case DtoType.TournamentSeasons:
break;
case DtoType.MarketDescriptionList:
break;
case DtoType.VariantDescription:
break;
case DtoType.VariantDescriptionList:
break;
case DtoType.Lottery:
break;
case DtoType.LotteryDraw:
break;
case DtoType.LotteryList:
break;
case DtoType.BookingStatus:
break;
case DtoType.SportCategories:
break;
case DtoType.AvailableSelections:
break;
case DtoType.TournamentInfoList:
break;
default:
ExecutionLog.LogWarning($"Trying to add unchecked dto type: {dtoType} for id: {id}.");
break;
}
//CacheLog.LogDebug($"Saving {id} COMPLETED. Saved={saved}.");
return(saved);
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
public Task <bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
var timerOptionsCache = new TimerOptions {
Context = "SdkCache", Name = $"SaveTo_{CacheName}", MeasurementUnit = Unit.Calls
};
var timerOptionsDtType = new TimerOptions {
Context = "SdkCache", Name = $"{dtoType}", MeasurementUnit = Unit.Calls
};
using (_metrics.Measure.Timer.Time(timerOptionsCache))
{
using (_metrics.Measure.Timer.Time(timerOptionsDtType))
{
var syncTask = new Task <bool>(() =>
{
var result = CacheAddDtoItem(id, item, culture, dtoType, requester);
return(result);
});
syncTask.Start();
return(syncTask);
}
}
}
public async Task GetInformationAboutOngoingEventAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetInformationAboutOngoingEventAsync");
var filePath = GetFile("match_timeline.{culture}.xml", culture);
var restDeserializer = new Deserializer <matchTimelineEndpoint>();
var mapper = new MatchTimelineMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.MatchTimeline, requester).ConfigureAwait(false);
}
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
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:
var category = item as CategoryDTO;
if (category != null)
{
AddCategory(id, category, culture);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(CategoryDTO), item.GetType());
}
break;
case DtoType.Competitor:
break;
case DtoType.CompetitorProfile:
break;
case DtoType.SimpleTeamProfile:
break;
case DtoType.Fixture:
var fixture = item as FixtureDTO;
if (fixture?.Tournament != null)
{
AddSport(fixture.SportId, fixture.Tournament.Sport, culture);
AddCategory(fixture.Tournament.Category.Id, fixture.Tournament.Category, fixture.SportId, new List <URN> {
fixture.Tournament.Id
}, culture);
}
else
{
LogSavingDtoConflict(id, typeof(FixtureDTO), item.GetType());
}
break;
case DtoType.MarketDescription:
break;
case DtoType.MatchSummary:
var match = item 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);
}
else
{
LogSavingDtoConflict(id, typeof(MatchDTO), item.GetType());
}
break;
case DtoType.MatchTimeline:
var timeline = item as MatchTimelineDTO;
if (timeline?.SportEvent != null)
{
AddDataFromSportEventSummary(timeline.SportEvent, culture);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchTimelineDTO), item.GetType());
}
break;
case DtoType.PlayerProfile:
break;
case DtoType.RaceSummary:
var stageDTO = item as StageDTO;
if (stageDTO != null)
{
if (stageDTO.Status != null)
{
AddDataFromSportEventSummary(stageDTO, culture);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(StageDTO), item.GetType());
}
break;
case DtoType.Sport:
var sport = item as SportDTO;
if (sport != null)
{
AddSport(id, sport, culture);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportDTO), item.GetType());
}
break;
case DtoType.SportList:
var sportList = item as EntityList <SportDTO>;
if (sportList != null)
{
foreach (var s in sportList.Items)
{
AddSport(s.Id, s, culture);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <SportDTO>), item.GetType());
}
break;
case DtoType.SportEventStatus:
break;
case DtoType.SportEventSummary:
var summary = item as SportEventSummaryDTO;
if (summary != null)
{
AddDataFromSportEventSummary(summary, culture);
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)
{
AddDataFromSportEventSummary(s, culture);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <SportEventSummaryDTO>), item.GetType());
}
break;
case DtoType.Tournament:
var tour = item as TournamentDTO;
if (tour != null)
{
AddSport(tour.Sport.Id, tour.Sport, culture);
AddCategory(tour.Category.Id, tour.Category, tour.Sport.Id, new List <URN> {
tour.Id
}, culture);
}
else
{
LogSavingDtoConflict(id, typeof(SportDTO), item.GetType());
}
break;
case DtoType.TournamentInfo:
var tourInfo = item as TournamentInfoDTO;
if (tourInfo != null)
{
AddSport(tourInfo.SportId, tourInfo.Sport, culture);
AddCategory(tourInfo.Category.Id, tourInfo.Category, tourInfo.Sport.Id, new List <URN> {
tourInfo.Id
}, culture);
}
else
{
LogSavingDtoConflict(id, typeof(SportDTO), item.GetType());
}
break;
case DtoType.TournamentSeasons:
var tourSeasons = item as TournamentSeasonsDTO;
if (tourSeasons?.Tournament != null)
{
var tourSeasonsTournament = tourSeasons.Tournament;
AddSport(tourSeasonsTournament.SportId, tourSeasonsTournament.Sport, culture);
AddCategory(tourSeasonsTournament.Category.Id, tourSeasonsTournament.Category, tourSeasonsTournament.Sport.Id, new List <URN> {
tourSeasonsTournament.Id
}, culture);
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)
{
AddDataFromSportEventSummary(lottery, culture);
//if (lottery.DrawEvents == null || !lottery.DrawEvents.Any())
//{
// _dataRouterManager.GetLotteryScheduleAsync(lottery.Id, culture);
//}
//else
//{
// _dataRouterManager.GetDrawFixtureAsync(lottery.DrawEvents.First().Id, culture);
//}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(LotteryDTO), item.GetType());
}
break;
case DtoType.LotteryDraw:
var lotteryDraw = item as DrawDTO;
if (lotteryDraw != null)
{
AddDataFromSportEventSummary(lotteryDraw, culture);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(DrawDTO), item.GetType());
}
break;
case DtoType.LotteryList:
var lotteryList = item as EntityList <LotteryDTO>;
if (lotteryList != null)
{
foreach (var s in lotteryList.Items)
{
AddDataFromSportEventSummary(s, culture);
}
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <LotteryDTO>), item.GetType());
}
break;
case DtoType.SportCategories:
var sportCategories = item as SportCategoriesDTO;
if (sportCategories != null)
{
AddSport(sportCategories.Sport.Id, sportCategories, culture);
AddCategories(sportCategories, culture);
}
else
{
LogSavingDtoConflict(id, typeof(SportCategoriesDTO), item.GetType());
}
break;
case DtoType.BookingStatus:
break;
case DtoType.AvailableSelections:
break;
default:
ExecutionLog.Warn($"Trying to add unchecked dto type: {dtoType} for id: {id}.");
break;
}
return(saved);
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
public Task <bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
var timerOptionsCache = new TimerOptions {
Context = "SdkCache", Name = $"SaveTo_{CacheName}", MeasurementUnit = Unit.Calls
};
var timerOptionsDtType = new TimerOptions {
Context = "SdkCache", Name = $"{dtoType}", MeasurementUnit = Unit.Calls
};
using (_metrics.Measure.Timer.Time(timerOptionsCache))
{
using (_metrics.Measure.Timer.Time(timerOptionsDtType))
{
//WriteLog($"{CacheName} ::> Saving DTO for id:{id}, lang:[{culture.TwoLetterISOLanguageName}] and type:{dtoType}.");
var syncTask = new Task <bool>(() =>
{
var result = CacheAddDtoItem(id, item, culture, dtoType, requester);
//WriteLog($"{CacheName} ::> Saving DTO for id:{id}, lang:[{culture.TwoLetterISOLanguageName}] and type:{dtoType} COMPLETED.");
return(result);
});
syncTask.Start();
return(syncTask);
}
}
}
public async Task <IEnumerable <URN> > GetSeasonsForTournamentAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetSeasonsForTournamentAsync");
var filePath = GetFile("tournament_seasons.{culture}.xml", culture);
var restDeserializer = new Deserializer <tournamentSeasons>();
var mapper = new TournamentSeasonsMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.TournamentSeasons, requester).ConfigureAwait(false);
var urns = new List <URN>();
foreach (var item in result.Seasons)
{
urns.Add(item.Id);
}
return(urns.AsEnumerable());
}
return(null);
}
/// <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);
}
/// <summary>
/// Get stage event period summary as an asynchronous operation
/// </summary>
/// <param name="id">The id of the sport event to be fetched</param>
/// <param name="culture">The language to be fetched</param>
/// <param name="requester">The cache item which invoked request</param>
/// <param name="competitorIds">The list of competitor ids to fetch the results for</param>
/// <param name="periods">The list of period ids to fetch the results for</param>
/// <returns>The periods summary or null if not found</returns>
public Task <PeriodSummaryDTO> GetPeriodSummaryAsync(URN id, CultureInfo culture, ISportEventCI requester, ICollection <URN> competitorIds = null, ICollection <int> periods = null)
{
throw new NotImplementedException();
}
public async Task GetSportEventFixtureAsync(URN id, CultureInfo culture, bool useCachedProvider, ISportEventCI requester)
{
RecordCall("GetSportEventFixtureAsync");
var filePath = GetFile(FixtureXml, culture);
var restDeserializer = new Deserializer <fixturesEndpoint>();
var mapper = new FixtureMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(id, result, culture, DtoType.Fixture, requester).ConfigureAwait(false);
}
}
public async Task <IEnumerable <Tuple <URN, URN> > > GetSportEventsForTournamentAsync(URN id, CultureInfo culture, ISportEventCI requester)
{
RecordCall("GetSportEventsForTournamentAsync");
var filePath = GetFile(TourScheduleXml, culture);
var restDeserializer = new Deserializer <tournamentSchedule>();
var mapper = new TournamentScheduleMapperFactory();
var stream = FileHelper.OpenFile(filePath);
var result = mapper.CreateMapper(restDeserializer.Deserialize(stream)).Map();
if (result != null)
{
await _cacheManager.SaveDtoAsync(URN.Parse($"sr:sport_events:{result.Items.Count()}"), result, culture, DtoType.SportEventSummaryList, requester).ConfigureAwait(false);
var urns = new List <Tuple <URN, URN> >();
foreach (var item in result.Items)
{
urns.Add(new Tuple <URN, URN>(item.Id, item.SportId));
}
return(urns.AsEnumerable());
}
return(null);
}
/// <summary>
/// Adds the item to the cache
/// </summary>
/// <param name="id">The identifier of the item</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
public Task<bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
var timer = Metric.Context($"AddDtoTo_{CacheName}").Timer($"{dtoType}", Unit.Calls);
using (timer.NewContext($"{id} [{culture.TwoLetterISOLanguageName}]"))
{
var syncTask = new Task<bool>(() =>
{
var result = CacheAddDtoItem(id, item, culture, dtoType, requester);
return result;
});
syncTask.Start();
return syncTask;
}
}
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 added</param>
/// <param name="culture">The culture of the data-transfer-object</param>
/// <param name="dtoType">Type of the dto 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>
public async Task <bool> CacheAddDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
var timerOptionsCache = new TimerOptions {
Context = "SdkCache", Name = $"SaveTo_{CacheName}", MeasurementUnit = Unit.Calls
};
var timerOptionsDtType = new TimerOptions {
Context = "SdkCache", Name = $"{dtoType}", MeasurementUnit = Unit.Calls
};
using (_metrics.Measure.Timer.Time(timerOptionsCache, MetricTags.Empty, $"{id} [{culture.TwoLetterISOLanguageName}]"))
{
using (_metrics.Measure.Timer.Time(timerOptionsDtType, MetricTags.Empty, $"{id} [{culture.TwoLetterISOLanguageName}]"))
{
var result = await CacheAddDtoItemAsync(id, item, culture, dtoType, requester).ConfigureAwait(false);
return(result);
}
}
}
/// <summary>
/// Adds the dto item to cache
/// </summary>
/// <param name="id">The identifier of the object</param>
/// <param name="item">The item</param>
/// <param name="culture">The culture</param>
/// <param name="dtoType">Type of the dto</param>
/// <param name="requester">The cache item which invoked request</param>
/// <returns><c>true</c> if added, <c>false</c> otherwise</returns>
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.MatchSummary:
if (SaveCompetitorsFromSportEvent(item, culture))
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchDTO), item.GetType());
}
break;
case DtoType.RaceSummary:
if (SaveCompetitorsFromSportEvent(item, culture))
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(StageDTO), item.GetType());
}
break;
case DtoType.TournamentInfo:
if (SaveCompetitorsFromSportEvent(item, culture))
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.SportEventSummary:
if (SaveCompetitorsFromSportEvent(item, culture))
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportEventSummaryDTO), item.GetType());
}
break;
case DtoType.Sport:
break;
case DtoType.Category:
break;
case DtoType.Tournament:
break;
case DtoType.PlayerProfile:
var playerProfile = item as PlayerProfileDTO;
if (playerProfile != null)
{
AddPlayerProfile(playerProfile, null, culture, true);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(PlayerProfileDTO), item.GetType());
}
break;
case DtoType.Competitor:
var competitor = item as CompetitorDTO;
if (competitor != null)
{
AddCompetitor(id, competitor, culture, true);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(CompetitorDTO), item.GetType());
}
break;
case DtoType.CompetitorProfile:
var competitorProfile = item as CompetitorProfileDTO;
if (competitorProfile != null)
{
AddCompetitorProfile(id, competitorProfile, culture, true);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(CompetitorProfileDTO), item.GetType());
}
break;
case DtoType.SimpleTeamProfile:
var simpleTeamProfile = item as SimpleTeamProfileDTO;
if (simpleTeamProfile != null)
{
AddCompetitorProfile(id, simpleTeamProfile, culture, true);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SimpleTeamProfileDTO), item.GetType());
}
break;
case DtoType.MarketDescription:
break;
case DtoType.SportEventStatus:
break;
case DtoType.MatchTimeline:
var matchTimeline = item as MatchTimelineDTO;
if (matchTimeline != null)
{
saved = SaveCompetitorsFromSportEvent(matchTimeline.SportEvent, culture);
}
else
{
LogSavingDtoConflict(id, typeof(MatchTimelineDTO), item.GetType());
}
break;
case DtoType.TournamentSeasons:
break;
case DtoType.Fixture:
if (SaveCompetitorsFromSportEvent(item, culture))
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(FixtureDTO), item.GetType());
}
break;
case DtoType.SportList:
break;
case DtoType.SportEventSummaryList:
break;
case DtoType.MarketDescriptionList:
break;
case DtoType.VariantDescription:
break;
case DtoType.VariantDescriptionList:
break;
case DtoType.Lottery:
break;
case DtoType.LotteryDraw:
break;
case DtoType.LotteryList:
break;
case DtoType.BookingStatus:
break;
case DtoType.SportCategories:
break;
case DtoType.AvailableSelections:
break;
case DtoType.TournamentInfoList:
break;
default:
ExecutionLog.LogWarning($"Trying to add unchecked dto type: {dtoType} for id: {id}.");
break;
}
return(saved);
}
/// <summary>
/// Adds the item to the all registered caches
/// </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 dto 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>
public async Task SaveDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(item, nameof(item)).NotNull();
Guard.Argument(culture, nameof(culture)).NotNull();
if (_caches == null || !_caches.Any())
{
return;
}
var appropriateCaches = _caches.Where(s => s.Value.RegisteredDtoTypes.Contains(dtoType)).ToList();
if (!appropriateCaches.Any())
{
ExecLog.LogWarning($"No cache with registered type:{dtoType} and lang:[{culture.TwoLetterISOLanguageName}] to save data.");
return;
}
var tasks = appropriateCaches.Select(c => c.Value.CacheAddDtoAsync(id, item, culture, dtoType, requester)).ToArray();
if (tasks.Any())
{
try
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception e)
{
ExecLog.LogError(e, $"Error saving dto data for id={id}, lang=[{culture.TwoLetterISOLanguageName}], type={dtoType}.");
}
}
else
{
ExecLog.LogWarning("Cannot save data. There is no registered cache.");
}
}
/// <summary>
/// Adds the dto item to cache
/// </summary>
/// <param name="id">The identifier of the object</param>
/// <param name="item">The item to be added</param>
/// <param name="culture">The culture of the item</param>
/// <param name="dtoType">Type of the dto</param>
/// <param name="requester">The cache item which invoked request</param>
/// <returns><c>true</c> if added, <c>false</c> otherwise</returns>
/// <exception cref="ArgumentOutOfRangeException">dtoType - null</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:
break;
case DtoType.MarketDescription:
var marketDescription = item as MarketDescriptionDTO;
if (marketDescription != null)
{
//WriteLog($"Saving {marketDescription.Id} variant description for lang: [{culture.TwoLetterISOLanguageName}].");
Merge(culture, marketDescription);
saved = true;
//WriteLog($"Saving {marketDescription.Id} variant description for lang: [{culture.TwoLetterISOLanguageName}] COMPLETED.");
}
else
{
LogSavingDtoConflict(id, typeof(MarketDescriptionDTO), item.GetType(), ExecutionLog);
}
break;
case DtoType.MarketDescriptionList:
break;
case DtoType.MatchSummary:
break;
case DtoType.MatchTimeline:
break;
case DtoType.PlayerProfile:
break;
case DtoType.RaceSummary:
break;
case DtoType.Sport:
break;
case DtoType.SportList:
break;
case DtoType.SportEventStatus:
break;
case DtoType.SportEventSummary:
break;
case DtoType.SportEventSummaryList:
break;
case DtoType.Tournament:
break;
case DtoType.TournamentInfo:
break;
case DtoType.TournamentSeasons:
break;
case DtoType.VariantDescription:
break;
case DtoType.VariantDescriptionList:
break;
case DtoType.Lottery:
break;
case DtoType.LotteryDraw:
break;
case DtoType.LotteryList:
break;
case DtoType.BookingStatus:
break;
case DtoType.SportCategories:
break;
case DtoType.AvailableSelections:
break;
case DtoType.TournamentInfoList:
break;
default:
ExecutionLog.LogWarning($"Trying to add unchecked dto type: {dtoType} for id: {id}.");
break;
}
return(saved);
}
/// <summary>
/// Adds the item to the all registered caches
/// </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 dto 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>
public void SaveDto(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
SaveDtoAsync(id, item, culture, dtoType, requester).Wait();
}
