/// <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(DestinyLocales locale, string trait)
{
return(_localisedRepositories[locale].Search <DestinyInventoryItemDefinition>(DefinitionsEnum.DestinyInventoryItemDefinition, x =>
{
var traits = (x as DestinyInventoryItemDefinition).TraitIds;
if (traits == null)
{
return false;
}
else
{
return traits.Contains(trait);
}
}).ToList());
}
public static string LocaleToString(this DestinyLocales locale)
{
return(locale switch
{
DestinyLocales.EN => "en",
DestinyLocales.RU => "ru",
DestinyLocales.DE => "de",
DestinyLocales.ES => "es",
DestinyLocales.ES_MX => "es-mx",
DestinyLocales.FR => "fr",
DestinyLocales.IT => "it",
DestinyLocales.JA => "ja",
DestinyLocales.KO => "ko",
DestinyLocales.PL => "pl",
DestinyLocales.PT_BR => "pt-br",
DestinyLocales.ZH_CHS => "zh-chs",
DestinyLocales.ZH_CHT => "zh-cht",
_ => throw new Exception("Wrong locale."),
});
internal DefinitionHashPointer(uint?hash, DefinitionsEnum type, DestinyLocales locale, T def = default, ILocalisedDestinyDefinitionRepositories repo = null)
{
if (def != null)
{
m_value = def;
Exists = true;
}
Hash = hash;
DefinitionEnumType = type;
if (repo != null)
{
_repository = repo;
}
else
{
_repository = StaticUnityContainer.GetDestinyDefinitionRepositories();
}
Locale = locale;
}
public string FetchJSONFromDB(DestinyLocales locale, DefinitionsEnum definitionType, uint hash)
{
if (!_assemblyData.DefinitionsToTypeMapping[definitionType].AttributeData.Sources.HasFlag(Attributes.DefinitionSources.SQLite))
{
throw new Exception("This definition type isn't present in SQLite database.");
}
var manifest = StaticUnityContainer.GetManifestUpdateHandler().CurrentManifest;
var mobileWorldContentPathsLocalePath = Path.GetFileName(manifest.MobileWorldContentPaths[locale.LocaleToString()]);
var connectionString = @$ "Data Source={_configs.Settings.VersionsRepositoryPath}\\{manifest.Version}\\MobileWorldContent\\{locale.LocaleToString()}\\{mobileWorldContentPathsLocalePath}; Version=3;";
string result = string.Empty;
using (SQLiteConnection connection = new SQLiteConnection(connectionString))
{
connection.Open();
string query = $"SELECT * FROM {definitionType.ToString()} WHERE id={hash.ToInt32()}";
SQLiteCommand command = new SQLiteCommand
{
Connection = connection,
CommandText = query
};
try
{
var reader = command.ExecuteReader();
while (reader.Read())
{
var byteArray = (byte[])reader["json"];
result = Encoding.UTF8.GetString(byteArray, 0, byteArray.Length);
}
}
catch (Exception e)
{
_logger.Log(e.Message, LogType.Error);
}
connection.Close();
}
return(result);
}
/// <summary>
/// Class .ctor
/// </summary>
/// <param name="locale">Locale for this repository</param>
internal DestinyDefinitionsRepository(DestinyLocales locale, IDefinitionAssemblyData assemblyData, IConfigurationService configuration, ILogger logger)
{
_assemblyData = assemblyData;
_config = configuration;
_logger = logger;
Locale = locale;
_loadRules =
_assemblyData.DefinitionsToTypeMapping
.Where(x => !_config.Settings.ExcludedDefinitions.Contains(x.Key))
.Where(x => x.Value.AttributeData.Sources.HasFlag(_config.Settings.PreferredLoadSource))
.ToDictionary(x => x.Key, x => _config.Settings.PreferredLoadSource);
if (_config.Settings.SpecifiedLoadSources.Count > 0)
{
foreach (var source in _config.Settings.SpecifiedLoadSources)
{
var definitionAssemblyRules = _assemblyData.DefinitionsToTypeMapping[source.Key];
if (definitionAssemblyRules.AttributeData.Sources.HasFlag(source.Value))
{
if (!_loadRules.TryAdd(source.Key, source.Value))
{
_loadRules[source.Key] = source.Value;
}
}
}
}
int definitionsLoaded = _loadRules.Count;
int concurrencyLevel = _config.Settings.AppConcurrencyLevel;
_logger.Log($"Initializing definitions repository with settings: Locale: {Locale}, Concurrency level: {concurrencyLevel}, Capacity: {definitionsLoaded}", LogType.Debug);
_definitionRepositories = new ConcurrentDictionary <DefinitionsEnum, DestinyDefinitionTypeRepository>(
concurrencyLevel: concurrencyLevel,
capacity: definitionsLoaded);
}
public IEnumerable <T> GetAll <T>(DestinyLocales locale = DestinyLocales.EN) where T : IDestinyDefinition
{
return(_localisedRepositories[locale].GetAll <T>(_assemblyData.TypeToEnumMapping[typeof(T)]));
}
public IEnumerable <T> GetAll <T>(DefinitionsEnum definitionType, DestinyLocales locale) where T : IDestinyDefinition
{
return(_localisedRepositories[locale].GetAll <T>(definitionType));
}
public IEnumerable <T> Search <T>(DefinitionsEnum definitionType, DestinyLocales locale, Func <IDestinyDefinition, bool> predicate) where T : IDestinyDefinition
{
return(_localisedRepositories[locale].Search <T>(definitionType, predicate));
}
public bool TryGetDestinyDefinition <T>(DefinitionsEnum definitionType, uint key, DestinyLocales locale, out T definition) where T : IDestinyDefinition
{
return(_localisedRepositories[locale].TryGetDefinition(definitionType, key, out definition));
}
public void AddDefinitionToCache(DefinitionsEnum definitionType, IDestinyDefinition defValue, DestinyLocales locale)
{
_localisedRepositories[locale].AddDefinition(definitionType, defValue);
}
public void SetLocaleContext(DestinyLocales locale)
{
_currentLocaleLoadContext = locale;
}
public List <DestinyActivityDefinition> SearchActivitiesByName(DestinyLocales locale, string name)
{
return(_localisedRepositories[locale]
.Search <DestinyActivityDefinition>(DefinitionsEnum.DestinyActivityDefinition, x => (x as DestinyActivityDefinition).DisplayProperties.Name.Contains(name, StringComparison.OrdinalIgnoreCase))
.ToList());
}
public List <DestinyInventoryItemDefinition> GetSacks(DestinyLocales locale)
{
return(_localisedRepositories[locale]
.Search <DestinyInventoryItemDefinition>(DefinitionsEnum.DestinyInventoryItemDefinition, x => (x as DestinyInventoryItemDefinition).Sack != null)
.ToList());
}
public static Dictionary <DestinyItemCategoryDefinition, List <DestinyInventoryItemDefinition> > GetItemsCategorized(this ILocalisedDestinyDefinitionRepositories repo, DestinyLocales locale)
{
var result = new Dictionary <DestinyItemCategoryDefinition, List <DestinyInventoryItemDefinition> >();
foreach (var category in repo.GetAll <DestinyItemCategoryDefinition>(locale))
{
List <DestinyInventoryItemDefinition> categorizedItems = new List <DestinyInventoryItemDefinition>();
result.Add(category, categorizedItems);
}
foreach (var item in repo.GetAll <DestinyInventoryItemDefinition>(locale))
{
foreach (var category in item.ItemCategories)
{
result[category.Value].Add(item);
}
}
return(result);
}
