public bool TryGetHistoricalStatDefinition(string key, BungieLocales locale,
out DestinyHistoricalStatsDefinition definition)
{
if (Repository.TryGetDestinyHistoricalDefinition(locale, key, out definition))
{
return(true);
}
var getterTask = DefinitionProvider.LoadHistoricalStatsDefinition(key, locale);
definition = getterTask.GetAwaiter().GetResult();
if (!getterTask.IsCompleted)
{
throw new Exception("ValueTask faulted to get result.");
}
if (definition is null)
{
return(false);
}
if (_configuration.CacheDefinitions)
{
Repository.AddDestinyHistoricalDefinition(locale, definition);
}
return(true);
}
public List <DestinyInventoryItemDefinition> GetSacks(BungieLocales locale)
{
return(_localisedRepositories[locale]
.Search <DestinyInventoryItemDefinition>(DefinitionsEnum.DestinyInventoryItemDefinition,
x => (x as DestinyInventoryItemDefinition).Sack != null)
.ToList());
}
public IEnumerable <DestinyHistoricalStatsDefinition> GetAllHistoricalStatsDefinitions(
BungieLocales locale)
{
return(_localisedRepositories.TryGetValue(locale, out var repository)
? repository.GetAllHistoricalStats
: null);
}
internal DestinyDefinitionsRepository(
BungieLocales locale,
IDefinitionAssemblyData assemblyData,
ILogger logger,
DefaultDestiny2DefinitionRepositoryConfiguration configuration)
{
_assemblyData = assemblyData;
_logger = logger;
Locale = locale;
var definitionsLoaded = configuration.AllowedDefinitions.Count;
var concurrencyLevel = configuration.AppConcurrencyLevel;
_logger.LogDebug(
"Initializing definitions repository with settings: Locale: {Locale}, Concurrency level: {ConcurrencyLevel}, Capacity: {DefinitionsLoaded}",
Locale, concurrencyLevel, definitionsLoaded);
_definitionRepositories = new ConcurrentDictionary <DefinitionsEnum, DestinyDefinitionTypeRepository>(
concurrencyLevel,
definitionsLoaded);
foreach (var definition in configuration.AllowedDefinitions)
{
_definitionRepositories.TryAdd(definition,
new DestinyDefinitionTypeRepository(
_assemblyData.DefinitionsToTypeMapping[definition].DefinitionType,
concurrencyLevel));
}
_historicalStatsDefinitions =
new ConcurrentDictionary <string, DestinyHistoricalStatsDefinition>(concurrencyLevel, 31);
}
/// <summary>
/// Class .ctor
/// </summary>
/// <param name="locale">Locale for this repository</param>
internal DestinyDefinitionsRepository(
BungieLocales locale,
IDefinitionAssemblyData assemblyData,
IConfigurationService configuration,
ILogger logger)
{
_assemblyData = assemblyData;
_config = configuration;
_logger = logger;
Locale = locale;
var definitionsLoaded = _config.Settings.DefinitionLoadingSettings.AllowedDefinitions.Length;
var concurrencyLevel = _config.Settings.DefinitionLoadingSettings.AppConcurrencyLevel;
_logger.Log(
$"Initializing definitions repository with settings: Locale: {Locale}, Concurrency level: {concurrencyLevel}, Capacity: {definitionsLoaded}",
LogType.Debug);
_definitionRepositories = new ConcurrentDictionary <DefinitionsEnum, DestinyDefinitionTypeRepository>(
concurrencyLevel,
definitionsLoaded);
foreach (var definition in configuration.Settings.DefinitionLoadingSettings.AllowedDefinitions)
{
_definitionRepositories.TryAdd(definition,
new DestinyDefinitionTypeRepository(
_assemblyData.DefinitionsToTypeMapping[definition].DefinitionType,
concurrencyLevel));
}
_historicalStatsDefinitions =
new ConcurrentDictionary <string, DestinyHistoricalStatsDefinition>(concurrencyLevel, 31);
}
public List <DestinyActivityDefinition> SearchActivitiesByName(BungieLocales locale, string name)
{
return(_localisedRepositories[locale]
.Search <DestinyActivityDefinition>(DefinitionsEnum.DestinyActivityDefinition,
x => (x as DestinyActivityDefinition).DisplayProperties.Name.Contains(name,
StringComparison.OrdinalIgnoreCase))
.ToList());
}
public bool TryGetDestinyHistoricalDefinition(
BungieLocales locale,
string key,
out DestinyHistoricalStatsDefinition statsDefinition)
{
statsDefinition = default;
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.TryGetHistoricalStatsDefinition(key, out statsDefinition));
}
public IEnumerable <T> Search <T>(
DefinitionsEnum definitionType,
BungieLocales locale,
Func <IDestinyDefinition, bool> predicate) where T : IDestinyDefinition
{
return(_localisedRepositories.TryGetValue(locale, out var repository)
? repository.Search <T>(definitionType, predicate)
: null);
}
public bool TryGetDestinyDefinition <T>(
uint key,
BungieLocales locale,
out T definition)
where T : IDestinyDefinition
{
definition = default;
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.TryGetDefinition(DefinitionHashPointer <T> .EnumValue, key, out definition));
}
/// <summary>
/// Gets all items with given trait
/// <para>Possible traits:</para>
/// <para>
/// item_type: weapon, armor, ghost_hologram, boost, emote, finisher, currency, engram, shader, emblem, consumable,
/// light_subclass, ghost,
/// weapon_ornament, ship, vehicle, aura, dark_subclass, bounty
/// </para>
/// <para>armor_type: head, chest, arms, legs, class</para>
/// <para>
/// weapon_type: rocket_launcher, sniper_rifle, grenade_launcher, pulse_rifle, shotgun, auto_rifle, sidearm, bow,
/// fusion_rifle, machinegun,
/// trace_rifle, hand_cannon, scout_rifle, submachinegun, sword, linear_fusion_rifle
/// </para>
/// <para>foundry: suros, fotc, hakke, omolon, veist, field_forged, tex_mechanica, daito</para>
/// <para>
/// faction: new_monarchy, trials, vanguard, iron_banner, crucible, dead_orbit, future_war_cult, gambit, mamba,
/// commando
/// </para>
/// <para>inventory_filtering: quest, bounty, featured</para>
/// <para>quest: new_light, seasonal, playlists, past, exotic, current_release</para>
/// <para>mamba_role: collector, defender, invader, killer</para>
/// </summary>
/// <param name="trait">Item trait to search for</param>
/// <returns></returns>
public List <DestinyInventoryItemDefinition> GetItemsWithTrait(BungieLocales locale, string trait)
{
return(_localisedRepositories[locale].Search <DestinyInventoryItemDefinition>(
DefinitionsEnum.DestinyInventoryItemDefinition, x =>
{
var traits = (x as DestinyInventoryItemDefinition).TraitIds;
if (traits == null)
{
return false;
}
return traits.Contains(trait);
}).ToList());
}
GetGroupItemsBySeason(this ILocalisedDestinyDefinitionRepositories repo, BungieLocales locale)
{
var result = new Dictionary <DestinySeasonDefinition, List <DestinyInventoryItemDefinition> >();
foreach (var season in repo.GetAll <DestinySeasonDefinition>(locale))
{
result.Add(season, new List <DestinyInventoryItemDefinition>());
}
foreach (var item in repo.GetAll <DestinyInventoryItemDefinition>(locale))
{
if (item.Season.TryGetDefinition(out var seasonDefinition))
{
result[seasonDefinition].Add(item);
}
}
return(result);
}
public static string LocaleToString(this BungieLocales locale)
{
return(locale switch
{
BungieLocales.EN => "en",
BungieLocales.RU => "ru",
BungieLocales.DE => "de",
BungieLocales.ES => "es",
BungieLocales.ES_MX => "es-mx",
BungieLocales.FR => "fr",
BungieLocales.IT => "it",
BungieLocales.JA => "ja",
BungieLocales.KO => "ko",
BungieLocales.PL => "pl",
BungieLocales.PT_BR => "pt-br",
BungieLocales.ZH_CHS => "zh-chs",
BungieLocales.ZH_CHT => "zh-cht",
_ => throw new Exception("Wrong locale.")
});
/// <summary>
/// <inheritdoc cref="IBungieClient.TryGetDefinitionAsync{T}" />
/// </summary>
/// <param name="hash"></param>
/// <param name="locale"></param>
/// <param name="success"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public async ValueTask <bool> TryGetDefinitionAsync <T>(uint hash, BungieLocales locale, Action <T> success)
where T : IDestinyDefinition
{
if (Repository.TryGetDestinyDefinition <T>(hash, locale, out var definition))
{
success(definition);
return(true);
}
definition = await DefinitionProvider.LoadDefinition <T>(hash, locale);
if (definition is null)
{
return(false);
}
if (_configuration.CacheDefinitions)
{
Repository.AddDefinition(locale, definition);
}
success(definition);
return(true);
}
public async ValueTask <bool> TryGetHistoricalStatDefinitionAsync(string key, BungieLocales locale,
Action <DestinyHistoricalStatsDefinition> success)
{
if (Repository.TryGetDestinyHistoricalDefinition(locale, key, out var definition))
{
success(definition);
return(true);
}
definition = await DefinitionProvider.LoadHistoricalStatsDefinition(key, locale);
if (definition is null)
{
return(false);
}
if (_configuration.CacheDefinitions)
{
Repository.AddDestinyHistoricalDefinition(locale, definition);
}
success(definition);
return(true);
}
GetItemsCategorized(this ILocalisedDestinyDefinitionRepositories repo, BungieLocales locale)
{
var result = new Dictionary <DestinyItemCategoryDefinition, List <DestinyInventoryItemDefinition> >();
foreach (var category in repo.GetAll <DestinyItemCategoryDefinition>(locale))
{
var categorizedItems = new List <DestinyInventoryItemDefinition>();
result.Add(category, categorizedItems);
}
foreach (var item in repo.GetAll <DestinyInventoryItemDefinition>(locale))
{
foreach (var category in item.ItemCategories)
{
if (category.TryGetDefinition(out var value))
{
result[value].Add(item);
}
}
}
return(result);
}
public bool TryGetDefinition <T>(uint hash, BungieLocales locale, out T definition) where T : IDestinyDefinition
{
if (Repository.TryGetDestinyDefinition(hash, locale, out definition))
{
return(true);
}
var defTask = DefinitionProvider.LoadDefinition <T>(hash, locale);
definition = defTask.GetAwaiter().GetResult();
if (!defTask.IsCompleted)
{
throw new Exception("ValueTask faulted to get result.");
}
if (definition is null)
{
return(false);
}
if (_configuration.CacheDefinitions)
{
Repository.AddDefinition(locale, definition);
}
return(true);
}
public bool AddDefinition(DefinitionsEnum enumValue, BungieLocales locale, IDestinyDefinition definition)
{
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.AddDefinition(enumValue, definition));
}
public bool AddDefinition <T>(BungieLocales locale, T definition) where T : IDestinyDefinition
{
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.AddDefinition(DefinitionHashPointer <T> .EnumValue, definition));
}
public IEnumerable <T> GetAll <T>(BungieLocales locale = BungieLocales.EN) where T : IDestinyDefinition
{
return(_localisedRepositories.TryGetValue(locale, out var repository)
? repository.GetAll <T>(DefinitionHashPointer <T> .EnumValue)
: null);
}
public void AddDefinitionToCache(DefinitionsEnum definitionType, IDestinyDefinition defValue,
BungieLocales locale)
{
_localisedRepositories[locale].AddDefinition(definitionType, defValue);
}
public bool AddDestinyHistoricalDefinition(BungieLocales locale,
DestinyHistoricalStatsDefinition statsDefinition)
{
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.AddDestinyHistoricalStatsDefinition(statsDefinition));
}
public bool TryGetDestinyDefinition(DefinitionsEnum definitionType, uint key, BungieLocales locale,
out IDestinyDefinition definition)
{
return(_localisedRepositories[locale].TryGetDefinition(definitionType, key, out definition));
}
public bool TryGetDestinyDefinition <T>(uint key, BungieLocales locale,
out T definition) where T : IDestinyDefinition
{
return(_localisedRepositories[locale]
.TryGetDefinition(DefinitionHashPointer <T> .EnumValue, key, out definition));
}
public abstract ValueTask <string> LoadHistoricalStatsDefinitionAsJson(string id, BungieLocales locale);
public abstract ValueTask <ReadOnlyCollection <T> > LoadAllDefinitions <T>(BungieLocales locale)
where T : IDestinyDefinition;
public abstract ValueTask <ReadOnlyCollection <T> > LoadMultipleDefinitions <T>(uint[] hashes, BungieLocales locale)
where T : IDestinyDefinition;
public abstract ValueTask <T> LoadDefinition <T>(uint hash, BungieLocales locale) where T : IDestinyDefinition;
public abstract ValueTask <string> ReadDefinitionAsJson(DefinitionsEnum enumValue, uint hash,
BungieLocales locale);
public bool TryGetDestinyHistoricalDefinition(BungieLocales locale, string key,
out DestinyHistoricalStatsDefinition statsDefinition)
{
return(_localisedRepositories[locale].TryGetHistoricalStatsDefinition(key, out statsDefinition));
}
public abstract ValueTask <DestinyHistoricalStatsDefinition> LoadHistoricalStatsDefinition(string id,
BungieLocales locale);
