public async Task ResolveVanityUrlAsync_Should_Succeed()
{
var response = await steamInterface.ResolveVanityUrlAsync("aro");
Assert.NotNull(response);
Assert.True(response.Data > 0);
}
/// <summary>
/// Queries the Steam Web API for a 64-bit Steam ID based on a provided string value.
/// </summary>
/// <param name="steamUser"></param>
/// <param name="value"></param>
/// <returns></returns>
private static async Task <ulong> ResolveSteamIdFromValueAsync(SteamUser steamUser, string value)
{
ulong steamId64 = 0;
var steamId = await steamUser.ResolveVanityUrlAsync(value);
steamId64 = steamId;
return(steamId64);
}
/// <summary>
/// Gets a Steam ID from a custom vanity URL, CANNOT include the https://steamcommunity.com part
/// </summary>
/// <param name="user"></param>
/// <returns>Returns the user ID, if found</returns>
public static ulong GetSteamIdFromCustomUrl(string user)
{
try
{
ulong id = steamUserInterface.ResolveVanityUrlAsync(user).GetAwaiter().GetResult().Data;
return(id);
}
catch (VanityUrlNotResolvedException)
{
return(0);
}
}
/// <summary>
/// Asynchronously gets the steam ID from a vanity URL.
/// </summary>
/// <param name="url">The users Steam URL.</param>
/// <returns>The users Steam ID</returns>
private async Task <ulong> getSteamIdVanityAsync(string url)
{
while (true)
{
try
{
var steamId = await steamInterface.ResolveVanityUrlAsync(url).ConfigureAwait(false);
return(steamId.Data);
}
catch { }
}
}
/// <summary>
/// Queries the Steam Web API for a 64-bit Steam ID based on a provided string value.
/// </summary>
/// <param name="steamUser"></param>
/// <param name="value"></param>
/// <returns></returns>
private static async Task <ulong> ResolveSteamIdFromValueAsync(SteamUser steamUser, string value)
{
ulong steamId64 = 0;
var result = await steamUser.ResolveVanityUrlAsync(value);
// the value didn't resolve to a 64-bit Steam ID
if (result.Success == 42) // returns 42 on "no match"
{
throw new VanityUrlNotResolvedException(ErrorMessages.VanityUrlNotResolved);
}
else
{
steamId64 = result.SteamId;
}
return(steamId64);
}
/// <summary>
/// Polls the Steam api to see if the player exists
/// </summary>
/// <param name="username"></param>
/// <returns>Bool: true if successful</returns>
public static async Task <bool> CheckUsername(string username)
{
Debug.Print("Searching for steam user ...");
var steamInterface = new SteamUser(APIKey);
SteamWebAPI2.Utilities.ISteamWebResponse <ulong> userKeyResponse;
try
{
userKeyResponse = await steamInterface.ResolveVanityUrlAsync(username);
userKey = userKeyResponse.Data;
}
catch (Exception e)
{
Debug.Print(e.Message);
MessageBoxResult error = MessageBox.Show("No player found");
return(false);
}
Debug.Print(userKey.ToString());
return(true);
}
public async Task <bool> UpdateProfile(string username)
{
if (!IsApiKeySet())
{
ApplicationConstants.MessageApiNotSet();
return(false);
}
try
{
var vanityResolveResponse = await _steamUser.ResolveVanityUrlAsync(username);
PlayerDetails = new ApplicationPlayerDetails();
await GetUserByIdAsync(vanityResolveResponse.Data, PlayerDetails);
return(true);
}
catch (VanityUrlNotResolvedException)
{
return(false);
}
}
public async Task <ulong> GetIdFromVanityAsync(string vanityUrl) => (await _steam.ResolveVanityUrlAsync(vanityUrl).ConfigureAwait(false)).Data;
public async Task <ulong> SteamVanityUrl(string url)
{
var response = await _steamUser.ResolveVanityUrlAsync(url);
return(response.Data);
}
public async Task SteamUser(CommandContext ctx, string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: SteamID or Community URL are required! Try **.su criticalflaw**");
}
else
{
var service = new BotServices();
var steam = new SteamUser(service.GetAPIToken("steam"));
SteamCommunityProfileModel profile = null;
ISteamWebResponse <PlayerSummaryModel> summary = null;
try
{
var decode = await steam.ResolveVanityUrlAsync(query);
profile = await steam.GetCommunityProfileAsync(decode.Data).ConfigureAwait(false);
summary = await steam.GetPlayerSummaryAsync(decode.Data).ConfigureAwait(false);
}
catch
{
profile = await steam.GetCommunityProfileAsync(ulong.Parse(query)).ConfigureAwait(false);
summary = await steam.GetPlayerSummaryAsync(ulong.Parse(query)).ConfigureAwait(false);
}
finally
{
if (profile != null && summary != null)
{
await ctx.TriggerTypingAsync();
var output = new DiscordEmbedBuilder()
.WithTitle(summary.Data.Nickname);
if (summary.Data.ProfileVisibility == ProfileVisibility.Public)
{
output.WithThumbnailUrl(profile.AvatarFull.ToString());
output.WithColor(DiscordColor.MidnightBlue);
output.WithUrl($"http://steamcommunity.com/id/{profile.SteamID}/");
output.WithFooter($"Steam ID: {profile.SteamID}");
output.AddField("Member since",
summary.Data.AccountCreatedDate.ToUniversalTime().ToString(CultureInfo.CurrentCulture), true);
if (!string.IsNullOrWhiteSpace(profile.Summary))
{
output.WithDescription(Regex.Replace(profile.Summary, "<[^>]*>", ""));
}
if (summary.Data.UserStatus != UserStatus.Offline)
{
output.AddField("Status:", summary.Data.UserStatus.ToString(), true);
}
else
{
output.AddField("Last seen:", summary.Data.LastLoggedOffDate.ToUniversalTime().ToString(CultureInfo.CurrentCulture), true);
}
output.AddField("VAC Banned?:", profile.IsVacBanned ? "YES" : "NO", true);
output.AddField("Trade Banned?:", profile.TradeBanState, true);
if (profile.InGameInfo != null)
{
output.AddField("In-Game:", $"[{profile.InGameInfo.GameName}]({profile.InGameInfo.GameLink})", true);
output.AddField("Game Server IP:", profile.InGameServerIP, true);
output.WithImageUrl(profile.InGameInfo.GameLogoSmall);
}
}
else
{
output.Description = "This profile is private...";
}
await ctx.RespondAsync(embed : output.Build());
}
else
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: No results found!");
}
}
}
}