/// <summary>
/// Loads all data from local repositories.
/// </summary>
/// <param name="localManifestPath">Local repository path.</param>
/// <param name="manifest">Manifest object</param>
public void LoadDataFromFiles(string localManifestPath, DestinyManifest manifest)
{
Stopwatch sw = new Stopwatch();
_logger.Log($"Started loading data for localization: {Locale}", LogType.Info);
var sqliteLoadedRepos = _loadRules
.Where(x => x.Value == DefinitionSources.SQLite)
.Select(x => x.Key)
.ToArray();
var jsonLoadedRepos = _loadRules.Where(x => x.Value == DefinitionSources.JSON).Select(x => x.Key).ToArray();
if (sqliteLoadedRepos.Length > 0)
{
_logger.Log($"Loading {sqliteLoadedRepos.Length} definitions from SQLite source.", LogType.Info);
sw.Start();
LoadDefinitionsFromSQLite(sqliteLoadedRepos, localManifestPath, manifest, sqliteLoadedRepos.Contains(DefinitionsEnum.DestinyHistoricalStatsDefinition));
sw.Stop();
_logger.Log($"Loaded definitions from SQLite: {sw.ElapsedMilliseconds} ms.", LogType.Info);
}
if (jsonLoadedRepos.Length > 0)
{
_logger.Log($"Loading {jsonLoadedRepos.Length} definitions from JSON source.", LogType.Info);
sw.Restart();
LoadDefinitionFromJSON(jsonLoadedRepos, localManifestPath, manifest); sw.Stop();
_logger.Log($"Loaded definitions from JSON files: {sw.ElapsedMilliseconds} ms.", LogType.Info);
}
}
public async ValueTask <DestinyGearAssetDefinitionGear> GetDestinyGearAssetDefinitionGearData(
string gearPath,
DestinyManifest manifest,
string game = "destiny2",
CancellationToken cancellationToken = default)
{
var gearContentPath = StringBuilderPool
.GetBuilder(cancellationToken)
.Append(string.Format(manifest.MobileGearCDN["Gear"], game))
.Append($"/{gearPath}")
.Build();
var stream = await _httpClient.GetStreamFromWebSourceAsync(gearContentPath);
return(await _bungieNetJsonSerializer.DeserializeAsync <DestinyGearAssetDefinitionGear>(stream.ContentStream));
}
public async Task LoadData()
{
if (_currentUsedManifest == null)
{
_currentUsedManifest = _manifests.Keys.Last();
}
_logger.Log("Downloading/verifying manifest data.", LogType.Info);
await _currentUsedManifest.DownloadAndSaveToLocalFiles(true);
var repo = StaticUnityContainer.GetDestinyDefinitionRepositories();
repo.LoadAllDataFromDisk(
localManifestPath: $"{_versionControlPath}\\{_currentUsedManifest.Version}",
manifest: _currentUsedManifest);
_logger.Log("Manifest load finished.", LogType.Info);
}
public void LoadAllDataFromDisk(string localManifestPath, DestinyManifest manifest)
{
foreach (var repo in _localisedRepositories.Values)
{
SetLocaleContext(repo.Locale);
repo.LoadDataFromFiles(localManifestPath, manifest);
ResetLocaleContext();
}
if (_configs.Settings.PremapDefinitionPointers)
{
_logger.Log("Premapping pointers...", LogType.Info);
foreach (var repo in _localisedRepositories.Select(x => x.Value))
{
repo.PremapPointers();
}
_logger.Log("Finished premapping pointers!", LogType.Info);
}
}
public async Task UpdateManifestData()
{
_logger.Log("Checking manifest version...", LogType.Info);
_logger.Log("Downloading latest manifest...", LogType.Info);
var latestManifest = await BungieClient.Platform.GetDestinyManifest();
var latestFoundEqual = _manifests.Keys.FirstOrDefault(x => x.Version.Equals(latestManifest.Response.Version));
if (latestFoundEqual != null)
{
_logger.Log("Manifest is already up to date.", LogType.Info);
_currentUsedManifest = latestFoundEqual;
}
else
{
_logger.Log("Manifest requires update.", LogType.Info);
_currentUsedManifest = latestManifest.Response;
}
}
public void LoadAllDataFromDisk(string localManifestPath, DestinyManifest manifest)
{
foreach (var repo in _localisedRepositories.Values)
{
SetLocaleContext(repo.Locale);
Task.Run(async() =>
await Provider.ReadDefinitionsToRepository(_configs.Settings.DefinitionLoadingSettings
.AllowedDefinitions));
ResetLocaleContext();
}
if (_configs.Settings.DefinitionLoadingSettings.PremapDefinitionPointers)
{
_logger.Log("Premapping pointers...", LogType.Info);
foreach (var repo in _localisedRepositories.Select(x => x.Value))
{
repo.PremapPointers();
}
_logger.Log("Finished premapping pointers!", LogType.Info);
}
}
public void Test01_GetDestinyManifest()
{
DestinyManifest manifest = _client.Destiny2.GetDestinyManifest();
}
private void LoadDefinitionFromJSON(DefinitionsEnum[] definitions, string localManifestPath, DestinyManifest manifest)
{
var jsonWolrdComponentContentLocalePath = manifest.JsonWorldComponentContentPaths[Locale.LocaleToString()];
var result = Parallel.ForEach(definitions, (definitionName) =>
{
_logger.Log($"Loading definitions from {definitionName} ({Locale})", LogType.Info);
using var fs = File.OpenRead($"{localManifestPath}/JsonWorldComponentContent/{Locale}/{definitionName}/{Path.GetFileName(jsonWolrdComponentContentLocalePath[_assemblyData.EnumToNameMapping[definitionName]])}");
using var sr = new StreamReader(fs, Encoding.UTF8);
var definitionJson = sr.ReadToEnd();
var definitionJObjectDictionary = JObject.Parse(definitionJson);
foreach (var entry in definitionJObjectDictionary)
{
var definitionType = _assemblyData.DefinitionsToTypeMapping[definitionName].DefinitionType;
_definitionRepositories.TryAdd(definitionName, new DestinyDefinitionTypeRepository(definitionType, _config.Settings.AppConcurrencyLevel));
var deserializedDestinyDefinition = (IDestinyDefinition)entry.Value.ToObject(definitionType);
AddDefinition(definitionName, deserializedDestinyDefinition);
}
});
GC.Collect();
}
private void LoadDefinitionsFromSQLite(DefinitionsEnum[] definitions, string localManifestPath, DestinyManifest manifest, bool loadHistoricalDefinitions)
{
var mobileWorldContentPathsLocalePath = Path.GetFileName(manifest.MobileWorldContentPaths[Locale.LocaleToString()]);
using (SQLiteConnection connection = new SQLiteConnection(
@$ "Data Source={localManifestPath}\\MobileWorldContent\\{Locale}\\{mobileWorldContentPathsLocalePath}; Version=3;"))
{
connection.Open();
foreach (var key in definitions)
{
if (key == DefinitionsEnum.DestinyHistoricalStatsDefinition)
{
continue;
}
var definitionType = _assemblyData.DefinitionsToTypeMapping[key].DefinitionType;
_definitionRepositories.TryAdd(key, new DestinyDefinitionTypeRepository(definitionType, _config.Settings.AppConcurrencyLevel));
_logger.Log($"Loading definitions from {key} ({Locale})", LogType.Info);
SQLiteCommand command = new SQLiteCommand()
{
Connection = connection, CommandText = GetSQLSelectQuery(key.ToString())
};
try
{
var reader = command.ExecuteReader();
while (reader.Read())
{
AddDefinition(key, ParseJsonFromSQLiteDataReader <IDestinyDefinition>(reader, definitionType));
}
}
catch (Exception e)
{
_logger.Log(e.Message, LogType.Error);
}
}
if (loadHistoricalDefinitions)
{
_historicalStatsDefinitions = new ConcurrentDictionary <string, DestinyHistoricalStatsDefinition>(_config.Settings.AppConcurrencyLevel, 31);
var definitionType = _assemblyData.DefinitionsToTypeMapping[DefinitionsEnum.DestinyHistoricalStatsDefinition].DefinitionType;
_logger.Log($"Loading definitions from DestinyHistoricalStatsDefinition ({Locale})", LogType.Info);
SQLiteCommand command = new SQLiteCommand()
{
Connection = connection,
CommandText = GetSQLSelectQuery(DefinitionsEnum.DestinyHistoricalStatsDefinition.ToString())
};
try
{
var reader = command.ExecuteReader();
while (reader.Read())
{
var definition = ParseJsonFromSQLiteDataReader <DestinyHistoricalStatsDefinition>(reader, definitionType);
_historicalStatsDefinitions.TryAdd(definition.StatId, definition);
}
}
catch (Exception e)
{
_logger.Log(e.Message, LogType.Error);
}
}
connection.Close();
}
}
public abstract Task DeleteManifestData(DestinyManifest manifestData);
public abstract Task DownloadNewManifestData(DestinyManifest manifestData);
