public async ValueTask <BungieResponse <SearchResultOfFireteamSummary> > SearchPublicAvailableClanFireteams(
AuthorizationTokenData authorizationToken,
FireteamPlatform platform,
DestinyActivityModeType activityType,
FireteamDateRange dateRange,
FireteamSlotSearch slotFilter,
int page = 0,
string langFilter = null,
CancellationToken cancellationToken = default)
{
if (!_configuration.HasSufficientRights(ApplicationScopes.ReadGroups))
{
throw new InsufficientScopeException(ApplicationScopes.ReadGroups);
}
var url = StringBuilderPool
.GetBuilder(cancellationToken)
.Append("/Fireteam/Search/Available/")
.AddUrlParam(((byte)platform).ToString())
.AddUrlParam(((int)activityType).ToString())
.AddUrlParam(((byte)dateRange).ToString())
.AddUrlParam(((byte)slotFilter).ToString())
.AddUrlParam(page.ToString())
.AddQueryParam("langFilter", langFilter, () => !string.IsNullOrWhiteSpace(langFilter))
.Build();
return(await _dotNetBungieApiHttpClient
.GetFromBungieNetPlatform <SearchResultOfFireteamSummary>(url, cancellationToken,
authorizationToken.AccessToken)
.ConfigureAwait(false));
}
public async ValueTask <BungieResponse <SearchResultOfFireteamSummary> > GetAvailableClanFireteams(
AuthorizationTokenData authData,
long groupId,
FireteamPlatform platform,
DestinyActivityModeType activityType,
FireteamDateRange dateRange,
FireteamSlotSearch slotFilter,
FireteamPublicSearchOption publicOnly,
int page = 0,
string langFilter = null,
CancellationToken token = default)
{
if (!_configuration.Settings.IdentificationSettings.ApplicationScopes.HasFlag(ApplicationScopes.ReadGroups))
{
throw new InsufficientScopeException(ApplicationScopes.ReadGroups);
}
var url = StringBuilderPool
.GetBuilder(token)
.Append("/Fireteam/Clan/")
.AddUrlParam(groupId.ToString())
.Append("Available/")
.AddUrlParam(((byte)platform).ToString())
.AddUrlParam(((int)activityType).ToString())
.AddUrlParam(((byte)dateRange).ToString())
.AddUrlParam(((byte)slotFilter).ToString())
.AddUrlParam(((byte)publicOnly).ToString())
.AddUrlParam(page.ToString())
.AddQueryParam("langFilter", langFilter, () => !string.IsNullOrWhiteSpace(langFilter))
.Build();
return(await _httpClient.GetFromBungieNetPlatform <SearchResultOfFireteamSummary>(url, token,
authData.AccessToken));
}
public async Task <IEnumerable <ClanStat> > GetClanStatsAsync(ulong userID, DestinyActivityModeType activityType)
{
using var scope = _scopeFactory.CreateScope();
var activitiesDB = scope.ServiceProvider.GetRequiredService <IClanActivitiesDB>();
var user = await activitiesDB.GetUserByDiscordIdAsync(userID);
if (user is null)
{
return(null);
}
var apiClient = scope.ServiceProvider.GetRequiredService <BungieApiClient>();
try
{
var clanStats = await apiClient.Api.Destiny2_GetClanAggregateStats(user.ClanID, ((int)activityType).ToString());
return(clanStats.Select(x => new ClanStat
{
StatName = x.StatId,
Value = x.Value.Basic.DisplayValue
}));
}
catch
{
return(new List <ClanStat>());
}
}
internal ActivityPlaylistItemEntry(uint activityHash, uint[] activityModeHashes, DestinyActivityModeType[] activityModeTypes, uint directActivityModeHash,
DestinyActivityModeType directActivityModeType, int weight)
{
Activity = new DefinitionHashPointer <DestinyActivityDefinition>(activityHash, DefinitionsEnum.DestinyActivityDefinition);
ActivityModes = activityModeHashes.DefinitionsAsReadOnlyOrEmpty <DestinyActivityModeDefinition>(DefinitionsEnum.DestinyActivityModeDefinition);
ActivityModeTypes = activityModeTypes.AsReadOnlyOrEmpty();
DirectActivityMode = new DefinitionHashPointer <DestinyActivityDefinition>(directActivityModeHash, DefinitionsEnum.DestinyActivityDefinition);
DirectActivityModeType = directActivityModeType;
Weight = weight;
}
internal DestinyHistoricalStatsActivity(uint referenceId, uint directorActivityHash, long instanceId, DestinyActivityModeType mode,
DestinyActivityModeType[] modes, bool isPrivate, BungieMembershipType membershipType)
{
ActivityReference = new DefinitionHashPointer <DestinyActivityDefinition>(referenceId, DefinitionsEnum.DestinyActivityDefinition);
DirectorActivity = new DefinitionHashPointer <DestinyActivityDefinition>(directorActivityHash, DefinitionsEnum.DestinyActivityDefinition);
InstanceId = instanceId;
Mode = mode;
Modes = modes.AsReadOnlyOrEmpty();
IsPrivate = isPrivate;
MembershipType = membershipType;
}
public async ValueTask <BungieResponse <DestinyActivityHistoryResults> > GetActivityHistory(
BungieMembershipType membershipType,
long destinyMembershipId,
long characterId,
int count = 25,
DestinyActivityModeType mode = DestinyActivityModeType.None,
int page = 0,
CancellationToken token = default)
{
return(await _apiAccess.GetActivityHistory(membershipType, destinyMembershipId, characterId, count, mode,
page, token));
}
/// <summary>
/// <inheritdoc cref="IFireteamMethodsAccess.GetActivePrivateClanFireteamCount" />
/// </summary>
/// <param name="platform"></param>
/// <param name="activityType"></param>
/// <param name="dateRange"></param>
/// <param name="slotFilter"></param>
/// <param name="page"></param>
/// <param name="langFilter"></param>
/// <param name="token"></param>
/// <returns></returns>
public async ValueTask <BungieResponse <SearchResultOfFireteamSummary> > SearchPublicAvailableClanFireteams(
FireteamPlatform platform,
DestinyActivityModeType activityType,
FireteamDateRange dateRange,
FireteamSlotSearch slotFilter,
int page = 0,
string langFilter = null,
CancellationToken token = default)
{
return(await _apiAccess.SearchPublicAvailableClanFireteams(_token, platform, activityType, dateRange,
slotFilter, page, langFilter, token));
}
/// <summary>
/// <inheritdoc cref="IFireteamMethodsAccess.GetActivePrivateClanFireteamCount" />
/// </summary>
/// <param name="authData"></param>
/// <param name="groupId"></param>
/// <param name="platform"></param>
/// <param name="activityType"></param>
/// <param name="dateRange"></param>
/// <param name="slotFilter"></param>
/// <param name="publicOnly"></param>
/// <param name="page"></param>
/// <param name="langFilter"></param>
/// <param name="token"></param>
/// <returns></returns>
public async ValueTask <BungieResponse <SearchResultOfFireteamSummary> > GetAvailableClanFireteams(
AuthorizationTokenData authData,
long groupId,
FireteamPlatform platform,
DestinyActivityModeType activityType,
FireteamDateRange dateRange,
FireteamSlotSearch slotFilter,
FireteamPublicSearchOption publicOnly,
int page = 0,
string langFilter = null,
CancellationToken token = default)
{
return(await _apiAccess.GetAvailableClanFireteams(_token, groupId, platform, activityType, dateRange,
slotFilter, publicOnly, page, langFilter, token));
}
internal DestinyActivityDefinition(ActivityGraphListEntry[] activityGraphList, int activityLevel, int activityLightLevel, ActivityLoadoutEntry[] loadouts,
ActivityLocationMappingDefinition[] activityLocationMappings, uint[] activityModeHashes, DestinyActivityModeType[] activityModeTypes, uint activityTypeHash,
ActivityChallengeEntry[] challenges, uint completionUnlockHash, uint destinationHash, uint directActivityModeHash, DestinyActivityModeType directActivityModeType,
DestinyDefinitionDisplayProperties displayProperties, ActivityGuidedGame guidedGame, bool inheritFromFreeRoam, ActivityInsertionPointEntry[] insertionPoints,
bool isPlaylist, bool isPvP, ActivityMatchmaking matchmaking, ActivityModifierEntry[] modifiers, ActivityUnlockString[] optionalUnlockStrings,
DestinyDefinitionDisplayProperties originalDisplayProperties, string pgcrImage, uint placeHash, ActivityPlaylistItemEntry[] playlistItems, string releaseIcon,
int releaseTime, ActivityRewardEntry[] rewards, DestinyDefinitionDisplayProperties selectionScreenDisplayProperties, bool suppressOtherRewards, int tier,
bool blacklisted, uint hash, int index, bool redacted)
{
ActivityGraphList = activityGraphList.AsReadOnlyOrEmpty();
ActivityLevel = activityLevel;
ActivityLightLevel = activityLightLevel;
ActivityLocationMappings = activityLocationMappings.AsReadOnlyOrEmpty();
ActivityModes = activityModeHashes.DefinitionsAsReadOnlyOrEmpty <DestinyActivityModeDefinition>(DefinitionsEnum.DestinyActivityModeDefinition);
ActivityModeTypes = activityModeTypes.AsReadOnlyOrEmpty();
ActivityType = new DefinitionHashPointer <DestinyActivityTypeDefinition>(activityTypeHash, DefinitionsEnum.DestinyActivityTypeDefinition);
Challenges = challenges.AsReadOnlyOrEmpty();
CompletionUnlockHash = completionUnlockHash;
Destination = new DefinitionHashPointer <DestinyDestinationDefinition>(destinationHash, DefinitionsEnum.DestinyDestinationDefinition);
DirectActivityMode = new DefinitionHashPointer <DestinyActivityModeDefinition>(directActivityModeHash, DefinitionsEnum.DestinyActivityModeDefinition);
DirectActivityModeType = directActivityModeType;
DisplayProperties = displayProperties;
GuidedGame = guidedGame;
InheritFromFreeRoam = inheritFromFreeRoam;
InsertionPoints = insertionPoints.AsReadOnlyOrEmpty();
IsPlaylist = isPlaylist;
IsPvP = isPvP;
Matchmaking = matchmaking;
Modifiers = modifiers.AsReadOnlyOrEmpty();
OptionalUnlockStrings = optionalUnlockStrings.AsReadOnlyOrEmpty();
OriginalDisplayProperties = originalDisplayProperties;
PgcrImage = pgcrImage;
Place = new DefinitionHashPointer <DestinyPlaceDefinition>(placeHash, DefinitionsEnum.DestinyPlaceDefinition);
PlaylistItems = playlistItems.AsReadOnlyOrEmpty();
ReleaseIcon = releaseIcon;
ReleaseTime = releaseTime;
Rewards = rewards.AsReadOnlyOrEmpty();
SelectionScreenDisplayProperties = selectionScreenDisplayProperties;
SuppressOtherRewards = suppressOtherRewards;
Tier = tier;
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
Loadouts = loadouts.AsReadOnlyOrEmpty();
}
internal DestinyActivityModeDefinition(ActivityModeCategory activityModeCategory, Dictionary <uint, DestinyActivityModeType> activityModeMappings, bool display,
DestinyDefinitionDisplayProperties displayProperties, string friendlyName, bool isAggregateMode, bool isTeamBased, DestinyActivityModeType modeType, int order,
uint[] parentHashes, string pgcrImage, bool supportsFeedFiltering, int tier, bool blacklisted, uint hash, int index, bool redacted)
{
ActivityModeCategory = activityModeCategory;
ActivityModeMappings = activityModeMappings.AsReadOnlyDictionaryWithDefinitionKeyOrEmpty <DestinyActivityDefinition, DestinyActivityModeType>(DefinitionsEnum.DestinyActivityDefinition);
Display = display;
DisplayProperties = displayProperties;
FriendlyName = friendlyName;
IsAggregateMode = isAggregateMode;
IsTeamBased = isTeamBased;
ModeType = modeType;
Order = order;
ParentModes = parentHashes.DefinitionsAsReadOnlyOrEmpty <DestinyActivityModeDefinition>(DefinitionsEnum.DestinyActivityModeDefinition);
PgcrImage = pgcrImage;
SupportsFeedFiltering = supportsFeedFiltering;
Tier = tier;
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
}
public static (string emoji, string activityTitle) GetActivityInfo(DestinyActivityModeType activityType, string activityName)
{
string emoji, activityTitle;
switch (activityType)
{
case Raid:
{
var raid = GetRaidType(activityName ?? string.Empty);
emoji = Emoji.GetActivityRaidEmoji(raid);
activityTitle = Translation.ActivityRaidTypes[raid] ?? activityName ?? Translation.ActivityNames[activityType][0];
}
break;
default:
{
emoji = Emoji.GetActivityEmoji(activityType);
activityTitle = activityName ?? Translation.ActivityNames[activityType][0];
}
break;
}
return(emoji, activityTitle);
}
/// <summary>
/// Gets activity history stats for indicated character.
/// </summary>
/// <param name="membershipType"></param>
/// <param name="destinyMembershipId"></param>
/// <param name="characterId"></param>
/// <param name="count"></param>
/// <param name="mode"></param>
/// <param name="page"></param>
/// <returns></returns>
public async Task <BungieResponse <DestinyActivityHistoryResults> > GetActivityHistory(BungieMembershipType membershipType, long destinyMembershipId, long characterId, int count = 25,
DestinyActivityModeType mode = DestinyActivityModeType.None, int page = 0)
{
return(await GetData <DestinyActivityHistoryResults>($"Destiny2/{membershipType}/Account/{destinyMembershipId}/Character/{characterId}/Stats/Activities/?count={count}&mode={mode}&page={page}"));
}
public static string GetActivityEmoji(DestinyActivityModeType activityType) =>
activityType switch
{
private int GetType(DestinyActivityModeType mode) =>
mode switch
{
public static int GetFireteamSize(DestinyActivityModeType activityType) =>
activityType switch
{
public async Task <LeaderboardContainer> GetLeaderboardAsync(ulong userID, DestinyActivityModeType activityType)
{
using var scope = _scopeFactory.CreateScope();
var activitiesDB = scope.ServiceProvider.GetRequiredService <IClanActivitiesDB>();
var user = await activitiesDB.GetUserByDiscordIdAsync(userID);
if (user is null)
{
return(null);
}
var mode = ((int)activityType).ToString();
var apiClient = scope.ServiceProvider.GetRequiredService <BungieApiClient>();
var statIDs = CommonData.Localization.Translation.StatNames.Keys;
var chunks = statIDs.Chunk(statIDs.Count() / 8 + 1);
ConcurrentBag <LeaderboardStat> stats = new();
var tasks = chunks.Select(x => Task.Run(async() =>
{
foreach (var statID in x)
{
try
{
var leaderboard = await apiClient.Api.Destiny2_GetClanLeaderboards(user.ClanID, 100, mode, statID);
var entries = leaderboard.First().Value.First().Value.Entries;
var userEntry = entries.First(y => y.Player.DestinyUserInfo.MembershipId == user.UserID);
var leaderboardEntries = new List <LeaderboardEntry>()
{
new LeaderboardEntry
{
IsCurrUser = true,
Rank = userEntry.Rank,
Value = userEntry.Value.Basic.DisplayValue,
UserName = $"{userEntry.Player.DestinyUserInfo.BungieGlobalDisplayName}#{userEntry.Player.DestinyUserInfo.BungieGlobalDisplayNameCode}",
DestinyClass = Enum.Parse <DestinyClass>(userEntry.Player.CharacterClass)
}
};
leaderboardEntries.AddRange(entries
.Take(3)
.Where(y => y.Rank != userEntry.Rank)
.Select(y => new LeaderboardEntry
{
IsCurrUser = false,
Rank = y.Rank,
Value = y.Value.Basic.DisplayValue,
UserName = $"{y.Player.DestinyUserInfo.BungieGlobalDisplayName}#{y.Player.DestinyUserInfo.BungieGlobalDisplayNameCode}",
DestinyClass = Enum.Parse <DestinyClass>(y.Player.CharacterClass)
}));
stats.Add(new LeaderboardStat
{
StatName = CommonData.Localization.Translation.StatNames[statID],
Leaders = leaderboardEntries.OrderBy(y => y.Rank)
});
}
catch { }
}
}));
await Task.WhenAll(tasks);
return(new LeaderboardContainer
{
LeaderboardStats = stats.OrderBy(x => x.StatName)
});
}
