/// <summary>
/// Creates the specified DTO type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="args">The args.</param>
/// <returns></returns>
public IDto Create(DtoType type, params object[] args)
{
// get type info
QualifiedTypeNameAttribute qualifiedNameAttr = EnumAttributeUtility <DtoType, QualifiedTypeNameAttribute> .GetEnumAttribute(type.ToString());
// Initialize instance
IDto instance = null;
// create instance
instance = (IDto)this.CreateObjectInstance(qualifiedNameAttr.AssemblyFileName, qualifiedNameAttr.QualifiedTypeName, args);
// return
return(instance);
}
private async Task LogSaveDtoAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
if (item != null)
{
var stopWatch = Stopwatch.StartNew();
await _cacheManager.SaveDtoAsync(id, item, culture, dtoType, requester).ConfigureAwait(false);
stopWatch.Stop();
if (stopWatch.ElapsedMilliseconds > 100)
{
Debug.WriteLine($"Saving took {stopWatch.ElapsedMilliseconds} ms. For id={id}, culture={culture.TwoLetterISOLanguageName} and dtoType={dtoType}.");
}
}
}
private void InitTableName()
{
var attr = DtoType.Attribute <TableAttribute>();
var name = attr?.SchemaQualifiedTableName;
if (name == null && SimpleSaveConfiguration.Configuration.AutoGenerateTableName)
{
TableName = SimpleSaveConfiguration.Configuration.PluralizeTableName
? $"{DtoType.Name}s"
: DtoType.Name;
return;
}
TableName = name;
}
/// <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 InitProperties()
{
IList <PropertyMetadata> writeable = new List <PropertyMetadata>();
var all = new List <PropertyMetadata>();
IsReferenceData = DtoType.HasAttribute <ReferenceDataAttribute>();
HasUpdateableForeignKeys = IsReferenceData &&
DtoType.Attribute <ReferenceDataAttribute>().HasUpdateableForeignKeys;
foreach (var prop in DtoType.PropertiesWith(Flags.InstancePublic))
{
var propMeta = new PropertyMetadata(prop);
all.Add(propMeta);
_propertiesByCaseInsensitiveColumnName[propMeta.ColumnName] = propMeta;
if (!propMeta.IsSaveable)
{
continue;
}
if (propMeta.IsPrimaryKey)
{
PrimaryKey = propMeta;
}
if (propMeta.IsSoftDeletable)
{
SoftDeleteProperty = propMeta;
}
writeable.Add(propMeta);
}
if (!string.IsNullOrEmpty(TableName))
{
// If this type represents a table then we want to deduplicate properties
// mapped to columns, otherwise we don't really care.
writeable = DeduplicateWriteablePropertiesMappedToColumns(writeable);
}
WriteableProperties = writeable;
AllProperties = all;
}
/// <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;
}
}
public virtual string CreateRequestOrResponse(Type type, string operation, DtoType dtoType)
{
if (type == typeof(string))
{
return("(string)");
}
if (type == typeof(byte[]))
{
return("(byte[])");
}
if (type == typeof(Stream))
{
return("(Stream)");
}
if (type == typeof(HttpWebResponse))
{
return("(HttpWebResponse)");
}
return(CreateMessage(type, operation, dtoType));
}
private void InitProperties()
{
IList <PropertyMetadata> writeable = new List <PropertyMetadata>();
var all = new List <PropertyMetadata>();
foreach (var prop in DtoType.GetProperties(
BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
var propMeta = new PropertyMetadata(prop);
all.Add(propMeta);
_propertiesByCaseInsensitiveColumnName[propMeta.ColumnName] = propMeta;
if (!propMeta.IsSaveable)
{
continue;
}
if (propMeta.IsPrimaryKey)
{
PrimaryKey = propMeta;
}
if (propMeta.HasAttribute <SoftDeleteColumnAttribute>())
{
SoftDeleteProperty = propMeta;
}
writeable.Add(propMeta);
}
if (HasAttribute <TableAttribute>())
{
// If this type represents a table then we want to deduplicate properties
// mapped to columns, otherwise we don't really care.
writeable = DeduplicateWriteablePropertiesMappedToColumns(writeable);
}
WriteableProperties = writeable;
AllProperties = all;
}
/// <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</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)
{
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 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);
}
}
}
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> >());
}
/// <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);
}
}
}
/// <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 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);
}
}
}
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);
}
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);
}
}
}
/// <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);
}
public CommandDto(DtoType dtoType) : base(dtoType)
{
}
protected virtual string CreateMessage(Type type, string operatinoName, DtoType dtoType)
{
return(CreateMessage(type));
}
/// <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();
}
/// <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);
protected DtoBase(DtoType dtoType)
{
DtoType = dtoType;
}
/// <summary>
/// Initializes a new instance of the <see cref="DtoBase"/> class.
/// </summary>
/// <param name="dtoType">Type of the dto.</param>
protected DtoBase(DtoType dtoType)
{
this.DtoType = dtoType;
this._uniqueId = Guid.NewGuid();
this.ObjectState = ObjectStateType.None;
}
private string GetDtoClassName(string methodName, DtoType type)
{
return(GetDtoClassName(methodName, type.ToString()));
}
/// <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 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 async Task <bool> CacheAddDtoItemAsync(URN id, object item, CultureInfo culture, DtoType dtoType, ISportEventCI requester)
{
if (_isDisposed)
{
return(false);
}
var saved = false;
switch (dtoType)
{
case DtoType.MatchSummary:
var competitorsSaved1 = await SaveCompetitorsFromSportEventAsync(item, culture).ConfigureAwait(false);
if (competitorsSaved1)
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(MatchDTO), item.GetType());
}
break;
case DtoType.RaceSummary:
var competitorsSaved2 = await SaveCompetitorsFromSportEventAsync(item, culture).ConfigureAwait(false);
if (competitorsSaved2)
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(StageDTO), item.GetType());
}
break;
case DtoType.TournamentInfo:
var competitorsSaved3 = await SaveCompetitorsFromSportEventAsync(item, culture).ConfigureAwait(false);
if (competitorsSaved3)
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(TournamentInfoDTO), item.GetType());
}
break;
case DtoType.SportEventSummary:
var competitorsSaved4 = await SaveCompetitorsFromSportEventAsync(item, culture).ConfigureAwait(false);
if (competitorsSaved4)
{
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)
{
await AddPlayerProfileAsync(playerProfile, null, culture, true).ConfigureAwait(false);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(PlayerProfileDTO), item.GetType());
}
break;
case DtoType.Competitor:
var competitor = item as CompetitorDTO;
if (competitor != null)
{
await AddCompetitorAsync(id, competitor, culture, true).ConfigureAwait(false);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(CompetitorDTO), item.GetType());
}
break;
case DtoType.CompetitorProfile:
var competitorProfile = item as CompetitorProfileDTO;
if (competitorProfile != null)
{
await AddCompetitorProfileAsync(id, competitorProfile, culture, true).ConfigureAwait(false);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(CompetitorProfileDTO), item.GetType());
}
break;
case DtoType.SimpleTeamProfile:
var simpleTeamProfile = item as SimpleTeamProfileDTO;
if (simpleTeamProfile != null)
{
await AddCompetitorProfileAsync(id, simpleTeamProfile, culture, true).ConfigureAwait(false);
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 = await SaveCompetitorsFromSportEventAsync(matchTimeline.SportEvent, culture).ConfigureAwait(false);
}
else
{
LogSavingDtoConflict(id, typeof(MatchTimelineDTO), item.GetType());
}
break;
case DtoType.TournamentSeasons:
var tournamentSeason = item as TournamentSeasonsDTO;
if (tournamentSeason?.Tournament != null)
{
await SaveCompetitorsFromSportEventAsync(tournamentSeason.Tournament, culture).ConfigureAwait(false);
saved = true;
}
break;
case DtoType.Fixture:
var competitorsSaved5 = await SaveCompetitorsFromSportEventAsync(item, culture).ConfigureAwait(false);
if (competitorsSaved5)
{
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(FixtureDTO), item.GetType());
}
break;
case DtoType.SportList:
break;
case DtoType.SportEventSummaryList:
var sportEventSummaryList = item as EntityList <SportEventSummaryDTO>;
if (sportEventSummaryList != null)
{
var tasks = sportEventSummaryList.Items.Select(s => SaveCompetitorsFromSportEventAsync(s, culture));
await Task.WhenAll(tasks).ConfigureAwait(false);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(SportEventSummaryDTO), item.GetType());
}
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:
var ts = item as EntityList <TournamentInfoDTO>;
if (ts != null)
{
var tasks = ts.Items.Select(s => SaveCompetitorsFromSportEventAsync(s, culture));
await Task.WhenAll(tasks).ConfigureAwait(false);
saved = true;
}
else
{
LogSavingDtoConflict(id, typeof(EntityList <TournamentInfoDTO>), item.GetType());
}
break;
default:
ExecutionLog.LogWarning($"Trying to add unchecked dto type: {dtoType} for id: {id}.");
break;
}
return(saved);
}
