public DestinyDefinitionAttribute(DefinitionsEnum type, DefinitionSources sources, DefinitionKeyType keyType, bool isManuallyDisabled = false)
{
DefinitionEnumType = type;
Sources = sources;
KeyType = keyType;
IsManuallyDisabled = isManuallyDisabled;
}
public async ValueTask <BungieResponse <T> > GetDestinyEntityDefinition <T>(
DefinitionsEnum entityType,
uint hash,
CancellationToken token = default) where T : IDestinyDefinition
{
return(await _apiAccess.GetDestinyEntityDefinition <T>(entityType, hash, token));
}
/// <summary>
/// Searches through repository with given predicate
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate"></param>
/// <returns></returns>
public IEnumerable <T> Search <T>(DefinitionsEnum definitionType, Func <IDestinyDefinition, bool> predicate)
where T : IDestinyDefinition
{
return(_definitionRepositories.TryGetValue(definitionType, out var repository)
? repository.Where(predicate).Cast <T>()
: null);
}
public async ValueTask <BungieResponse <DestinyEntitySearchResult> > SearchDestinyEntities(
DefinitionsEnum type,
string searchTerm,
int page = 0,
CancellationToken token = default)
{
return(await _apiAccess.SearchDestinyEntities(type, searchTerm, page, token));
}
/// <summary>
/// Removes definition from repository, if possible
/// </summary>
/// <param name="definitionType"></param>
/// <param name="hash"></param>
/// <returns></returns>
public bool RemoveDefinition(DefinitionsEnum definitionType, uint hash)
{
if (_definitionRepositories.TryGetValue(definitionType, out var repository))
{
return(repository.Remove(hash));
}
return(false);
}
public void SetData(DefinitionsEnum definition, object data)
{
if (!Connected)
{
return;
}
simClient.SetDataOnSimObject(definition, SimConnect.SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_DATA_SET_FLAG.DEFAULT, data);
}
public void RequestData(RequestsEnum request, DefinitionsEnum definition)
{
if (!Connected)
{
return;
}
simClient.RequestDataOnSimObjectType(request, definition, 0, SIMCONNECT_SIMOBJECT_TYPE.USER);
}
/// <summary>
/// Struct .ctor
/// </summary>
/// <param name="hash">Definition hash</param>
/// <param name="type">Definition type</param>
public DefinitionHashPointer(uint?hash, DefinitionsEnum type)
{
m_value = default;
Exists = false;
Hash = hash;
DefinitionEnumType = type;
_repository = StaticUnityContainer.GetDestinyDefinitionRepositories();
Locale = _repository.CurrentLocaleLoadContext;
}
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);
}
/// <summary>
/// Adds definition from repository, if possible
/// </summary>
/// <param name="definitionType"></param>
/// <param name="definition"></param>
/// <returns></returns>
public bool AddDefinition(DefinitionsEnum definitionType, IDestinyDefinition definition)
{
if (_definitionRepositories.TryGetValue(definitionType, out var repository))
{
return(repository.Add(definition));
}
else
{
return(false);
}
}
public IEnumerable <T> GetAll <T>(DefinitionsEnum definitionType)
{
if (_definitionRepositories.TryGetValue(definitionType, out var repository))
{
return(repository.EnumerateValues().Cast <T>());
}
else
{
return(null);
}
}
AsReadOnlyDictionaryWithDefinitionKeyOrEmpty <T, P>(this Dictionary <uint, P> dictionary,
DefinitionsEnum enumValue) where T : IDestinyDefinition
{
if (dictionary is null)
{
return(new ReadOnlyDictionary <DefinitionHashPointer <T>, P>(
new Dictionary <DefinitionHashPointer <T>, P>(0)));
}
var convertedDict = dictionary.ToDictionary(x => new DefinitionHashPointer <T>(x.Key), y => y.Value);
return(new ReadOnlyDictionary <DefinitionHashPointer <T>, P>(convertedDict));
}
public async ValueTask <BungieResponse <T> > GetDestinyEntityDefinition <T>(DefinitionsEnum entityType, uint hash,
CancellationToken token = default) where T : IDestinyDefinition
{
var url = StringBuilderPool
.GetBuilder(token)
.Append("/Destiny2/Manifest/")
.AddUrlParam(entityType.ToString())
.AddUrlParam(hash.ToString())
.Build();
return(await _httpClient.GetFromBungieNetPlatform <T>(url, token));
}
/// <summary>
/// Gets definition from repository, if possible
/// </summary>
/// <param name="definitionType"></param>
/// <param name="hash"></param>
/// <param name="definition"></param>
/// <returns></returns>
public bool TryGetDefinition(DefinitionsEnum definitionType, uint hash, out IDestinyDefinition definition)
{
definition = default;
if (_definitionRepositories.TryGetValue(definitionType, out var repository))
{
if (repository.TryGetDefinition(hash, out definition))
{
return(definition != null);
}
return(false);
}
return(false);
}
public async ValueTask <BungieResponse <DestinyEntitySearchResult> > SearchDestinyEntities(
DefinitionsEnum type,
string searchTerm,
int page = 0,
CancellationToken token = default)
{
var url = StringBuilderPool
.GetBuilder(token)
.Append("/Destiny2/Armory/Search/")
.AddUrlParam(type.ToString())
.AddUrlParam(searchTerm)
.AddQueryParam("page", page.ToString())
.Build();
return(await _httpClient.GetFromBungieNetPlatform <DestinyEntitySearchResult>(url, token));
}
/// <summary>
/// Gets definition from repository, if possible
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="hash"></param>
/// <param name="definition"></param>
/// <returns></returns>
public bool TryGetDefinition <T>(DefinitionsEnum enumValue, uint hash, out T definition)
where T : IDestinyDefinition
{
definition = default;
if (_definitionRepositories.TryGetValue(enumValue, out var repository))
{
if (repository.TryGetDefinition <T>(hash, out var value))
{
definition = value;
return(definition != null);
}
return(false);
}
return(false);
}
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);
}
public ProviderUnsupportedException(string message, DefinitionsEnum enumValue) : base(message)
{
EnumValue = enumValue;
}
public DestinyDefinitionAttribute(DefinitionsEnum type, bool isManuallyDisabled = false)
{
DefinitionEnumType = type;
IsManuallyDisabled = isManuallyDisabled;
}
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);
}
internal static ReadOnlyCollection <DefinitionHashPointer <T> > DefinitionsAsReadOnlyOrEmpty <T>(this uint[] source, DefinitionsEnum enumValue) where T : IDestinyDefinition
{
ReadOnlyCollection <DefinitionHashPointer <T> > readOnlyCollection;
if (source != null)
{
readOnlyCollection = new ReadOnlyCollection <DefinitionHashPointer <T> >(source.Select(x => new DefinitionHashPointer <T>(x, enumValue)).ToArray());
}
else
{
readOnlyCollection = new ReadOnlyCollection <DefinitionHashPointer <T> >(new DefinitionHashPointer <T> [0]);
}
return(readOnlyCollection);
}
/// <summary>
/// Returns the static definition of an entity of the given Type and hash identifier.
/// </summary>
/// <typeparam name="T">Type of entity.</typeparam>
/// <param name="entityType">The type of entity for whom you would like results.</param>
/// <param name="hash">The hash identifier for the specific Entity you want returned.</param>
/// <returns></returns>
public async Task <BungieResponse <T> > GetDestinyEntityDefinition <T>(DefinitionsEnum entityType, uint hash) where T : IDestinyDefinition
{
return(await GetData <T>($"Destiny2/Manifest/{entityType}/{hash}"));
}
/// <summary>
/// Gets a page list of Destiny items.
/// </summary>
/// <param name="type">The type of entity for whom you would like results.</param>
/// <param name="searchTerm">The string to use when searching for Destiny entities.</param>
/// <param name="page">Page number to return</param>
/// <returns></returns>
public async Task <BungieResponse <DestinyEntitySearchResult> > SearchDestinyEntities(DefinitionsEnum type, string searchTerm, int page = 0)
{
return(await GetData <DestinyEntitySearchResult>($"Destiny2/Armory/Search/{type}/{searchTerm}/?page={page}"));
}
public bool AddDefinition(DefinitionsEnum enumValue, BungieLocales locale, IDestinyDefinition definition)
{
return(_localisedRepositories.TryGetValue(locale, out var repository) &&
repository.AddDefinition(enumValue, definition));
}
internal static ReadOnlyCollection <DefinitionHashPointer <T> > DefinitionsAsReadOnlyOrEmpty <T>(this uint[] source,
DefinitionsEnum enumValue) where T : IDestinyDefinition
{
if (source is null)
{
return(new ReadOnlyCollection <DefinitionHashPointer <T> >(Array.Empty <DefinitionHashPointer <T> >()));
}
IList <DefinitionHashPointer <T> > convertedList = new List <DefinitionHashPointer <T> >(source.Length);
for (var i = 0; i < source.Length; i++)
{
convertedList.Add(new DefinitionHashPointer <T>(source[i]));
}
return(new ReadOnlyCollection <DefinitionHashPointer <T> >(convertedList));
}
public abstract ValueTask <string> ReadDefinitionAsJson(DefinitionsEnum enumValue, uint hash,
BungieLocales locale);