public async Task <bool> GetUserByIdAsync(ulong steamId, ApplicationPlayerDetails toFill)
{
if (!IsApiKeySet())
{
return(false);
}
toFill.SteamId = steamId;
toFill.EverythingLoaded = false;
try
{
// Player profile
var playerSummaryResponse = await _steamUser.GetPlayerSummaryAsync(steamId);
toFill.PlayerProfile = playerSummaryResponse.Data;
// Friend list
var friendListResponse = await _steamUser.GetFriendsListAsync(steamId);
toFill.Friends = friendListResponse.Data.Select(x => x.SteamId).ToList();
// Owned games
var ownedGamesResponse = await _steamPlayerService.GetOwnedGamesAsync(steamId);
toFill.OwnedGames = ownedGamesResponse.Data;
toFill.EverythingLoaded = true;
return(true);
}
catch (SteamIdNotConstructedException)
{
return(false);
}
}
private async Task <PlayerSummaryModel> GetUserInfo(long steamId)
{
var id = Convert.ToUInt64(steamId);
var response = await _steamUserInterface.GetPlayerSummaryAsync(id);
return(response.Data);
}
public async Task <PlayerSummaryModel> Users(ulong playerID)
{
PlayerSummaryModel data = memCache.Get <PlayerSummaryModel>($"SteamInterface.GetPlayerSummaryAsync({playerID})");
if (data != null)
{
return(data);
}
try
{
ISteamWebResponse <PlayerSummaryModel> wrappedData = await steamInterface.GetPlayerSummaryAsync(playerID);
data = wrappedData.Data;
if (data == null)
{
return(data);
}
memCache.Set($"SteamInterface.GetPlayerSummaryAsync({playerID})", data, TimeSpan.FromHours(1));
return(data);
}
catch { }
return(null);
}
/// <summary>
/// 获取Steam用户信息
/// </summary>
/// <param name="steamID"></param>
/// <returns></returns>
public async Task <PlayerSummaryModel> GetPlayerSummary(string steamID)
{
SteamUser iUser = WebInterfaceFactory.CreateSteamWebInterface <SteamUser>();
ISteamWebResponse <PlayerSummaryModel> response = await iUser.GetPlayerSummaryAsync(ulong.Parse(steamID));
return(response.Data);
}
public async Task GetPlayerSummaryAsync_Should_Succeed()
{
var response = await steamInterface.GetPlayerSummaryAsync(76561198050013009);
Assert.NotNull(response);
Assert.NotNull(response.Data);
}
public Tuple <string, string> GetUserInfo(ulong steamId)
{
var i = new SteamUser(_apiKey);
var t = i.GetPlayerSummaryAsync(steamId);
PlayerSummaryModel m = t.Result.Data;
return(new Tuple <string, string>(m.Nickname, m.AvatarMediumUrl));
}
// this will map to ISteamUser/GetPlayerSummaries method in the Steam Web API
// see PlayerSummaryResultContainer.cs for response documentation
static async void GetPlayerSummary(ulong steamID, SteamUser steamInterface)
{
var playerSummaryResponse = await steamInterface.GetPlayerSummaryAsync(steamID);
var playerSummaryData = playerSummaryResponse.Data;
//player = JsonConvert.DeserializeObject<PlayerSummaryModel>(playerSummaryResponse);
}
private static async Task <SteamWebAPI2.Utilities.ISteamWebResponse <Steam.Models.SteamCommunity.PlayerSummaryModel> > GetPlayerSummary(string steamID3)
{
uint uintAccountID = (uint)Convert.ToUInt64(Int32.Parse(steamID3));
SteamUser steamUser = new SteamUser(APIKey);
SteamId sid = new SteamId(uintAccountID);
var playerSummary = await steamUser.GetPlayerSummaryAsync(sid.To64Bit());
return(playerSummary);
}
public async Task <IDictionary <string, uint> > GetCurrentPlayingGameUserAchievementsAsync(ulong steamId)
{
var user = new SteamUser(SteamSettings.WebApiKey);
var playerSummaryResponse = await user.GetPlayerSummaryAsync(steamId);
var gameId = uint.Parse(playerSummaryResponse.Data.PlayingGameId);
var stats = new SteamUserStats(SteamSettings.WebApiKey);
var currentGameStatsResponse = await stats.GetUserStatsForGameAsync(steamId, gameId);
return(currentGameStatsResponse.Data.Achievements.ToDictionary(x => x.Name, x => x.Achieved));
}
public async Task SteamInfo()
{
string userID = Context.User.Id.ToString();
string steamID = await DataStorage.getSteamID(userID);
var playerSummaryResponse = await steamInterface.GetPlayerSummaryAsync(Convert.ToUInt64(steamID));
var playerSummaryData = playerSummaryResponse.Data;
string nickName = playerSummaryData.Nickname;
string avatar = playerSummaryData.AvatarFullUrl;
string gamePlaying = playerSummaryData.PlayingGameName;
if (gamePlaying == null)
{
gamePlaying = "Nothing";
}
string profile = playerSummaryData.ProfileUrl;
string userStatus = playerSummaryData.UserStatus.ToString();
string createdDate = playerSummaryData.AccountCreatedDate.ToString();
string description = "";
description += "Currently Playing: " + gamePlaying + "\n";
description += "User Status: " + userStatus + "\n";
description += "Account Created: " + createdDate + "\n";
embed.WithTitle(nickName);
embed.WithDescription(description);
embed.WithUrl(profile);
embed.WithThumbnailUrl(avatar);
embed.WithColor(0, 173, 238);
await Context.Channel.SendMessageAsync("", false, embed);
ds.addPoints(userID, 5);
await checkLevel(userID);
}
private static async Task ParseNewSteamIds()
{
try {
List <string> steamIdsToParse = FetchSteamIds(true);
using (BatchQueryBuilder batchQuerybuilder = new BatchQueryBuilder(_config.ConnString)) {
SteamUser steamInterface = new SteamUser(_config.SteamWebApiKey);
foreach (string i in steamIdsToParse)
{
if (i == "0")
{
continue;
}
try {
Console.WriteLine($"Parsing Steam ID {i}");
PlayerSummaryModel playerSummaryResponseData = (await steamInterface.GetPlayerSummaryAsync(ulong.Parse(i))).Data;
IReadOnlyCollection <PlayerBansModel> playerBansResponseData = (await steamInterface.GetPlayerBansAsync(ulong.Parse(i))).Data;
IReadOnlyCollection <FriendModel> playerFriendsResponseData = null;
if (playerSummaryResponseData.ProfileVisibility == ProfileVisibility.Public)
{
playerFriendsResponseData = (await steamInterface.GetFriendsListAsync(ulong.Parse(i))).Data;
}
batchQuerybuilder.AppendSqlCommand(new MySqlCommand($"UPDATE FamilyRpServerAccess.ParsedSteamAccounts SET SteamCreated = '{playerSummaryResponseData.AccountCreatedDate:s}', RowUpdated = NOW()," +
$"SteamName = '{MySqlHelper.EscapeString( Utf8ToAscii( playerSummaryResponseData.Nickname ) )}'," +
$"SteamVisibility = '{playerSummaryResponseData.ProfileVisibility}'," +
$"NumSteamFriends = {playerFriendsResponseData?.Count ?? 0}," +
$"SteamBans = {playerBansResponseData.First().NumberOfGameBans + (playerBansResponseData.First().CommunityBanned ? 1 : 0) + playerBansResponseData.First().NumberOfVACBans}," +
"isParsed = 1 " +
$"WHERE SteamId = {i};"));
AuditLog(null, "Steam", "Parsed", "", i, batchQuerybuilder);
}
catch (Exception ex) {
if (!(ex.ToString().Contains("System.Net.Http.HttpRequestException") && ex.ToString().Contains("Unauthorized")))
{
Console.WriteLine($"Could not fetch Steam ID {i}: {ex}");
}
}
}
}
}
catch (Exception ex) {
Console.WriteLine($"{ex}");
}
}
public async Task <PlayerSummaryModel> GetSteamUserData(ulong id)
{
if (steamInterface == null)
{
return(null);
}
Tuple <DateTime, PlayerSummaryModel> newPlayerData = null;
if (steamPlayerCache.TryGetValue(id, out newPlayerData))
{
if (newPlayerData.Item1 > DateTime.UtcNow)
{
newPlayerData = null;
}
}
if (newPlayerData == null)
{
ISteamWebResponse <PlayerSummaryModel> playerData = await Task.Run(async() =>
{
try
{
ISteamWebResponse <PlayerSummaryModel> msg = await steamInterface.GetPlayerSummaryAsync(id);
return(msg);
}
catch
{
return(null);
}
});
if (playerData != null)
{
newPlayerData = new Tuple <DateTime, PlayerSummaryModel>(DateTime.UtcNow.AddHours(1), playerData.Data);
steamPlayerCache.AddOrUpdate(id, newPlayerData,
(key, existingVal) =>
{
return(newPlayerData);
});
}
}
return(newPlayerData?.Item2);
}
/// <summary>
/// Handles the Click event of the doneButton control.
/// Makes sure that the Steam API key is valid and closes this form to allow the next form to open.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private async void doneButton_Click(object sender, EventArgs e)
{
try
{
SteamWebInterfaceFactory webInterfaceFactory = new SteamWebInterfaceFactory(apiKeyTextBox.Text);
SteamUser steamInterface = webInterfaceFactory.CreateSteamWebInterface <SteamUser>(new HttpClient());
await steamInterface.GetPlayerSummaryAsync(76561197977699530).ConfigureAwait(false); // SteamId of https://steamcommunity.com/id/valve
Program.SteamApiKey = apiKeyTextBox.Text;
Invoke(new MethodInvoker(() => Close()));
}
catch
{
if (MessageBox.Show("Encountered an error while trying to use the API Key. Would you like to continue without an API Key?", "API Key Error", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
Program.SteamApiKey = "";
Invoke(new MethodInvoker(() => Close()));
}
}
}
private async Task RunSteamStuff()
{
// this will map to the ISteamUser endpoint
var steamInterface = new SteamUser(config.ApiKey);
var player = new PlayerService(config.ApiKey);
TimeSpanConverter converter = new TimeSpanConverter();
var playerSummaryResponse = await steamInterface.GetPlayerSummaryAsync(ulong.Parse(steamidInput.Text));
var playerSummaryData = playerSummaryResponse.Data;
outputText.Text = playerSummaryData.Nickname;
timespan = (TimeSpan)converter.ConvertFromString(hourInput.Text + ":" + minuteInput.Text + ":" + secondInput.Text);
var ownedgames = await player.GetOwnedGamesAsync(config.UserId, includeAppInfo : true, includeFreeGames : cb_freeGames.Checked);
var gamesdata = ownedgames.Data;
games = gamesdata.OwnedGames.ToList();
if (radioSortNameA.Checked)
{
games = games.OrderBy(x => x.Name).ToList();
DisplayGameList(games);
}
else if (radioSortTimeD.Checked)
{
games = games.OrderByDescending(x => x.PlaytimeForever).ToList();
DisplayGameList(games);
}
else if (radioSortTimeA.Checked)
{
games = games.OrderBy(x => x.PlaytimeForever).ToList();
DisplayGameList(games);
}
else if (radioSortNameD.Checked)
{
games = games.OrderByDescending(x => x.Name).ToList();
DisplayGameList(games);
}
DisplayGameList(games);
}
private static async Task ParseNewSteamIds()
{
List <string> SteamIdsToParse = FetchSteamIds(true);
using (BatchQueryBuilder batchQuerybuilder = new BatchQueryBuilder(config.ConnString))
{
var steamInterface = new SteamUser(config.SteamWebApiKey, null);
foreach (string i in SteamIdsToParse)
{
if (i == "0")
{
continue;
}
try
{
Console.WriteLine($"Parsing Steam ID {i}");
var playerSummaryResponseData = (await steamInterface.GetPlayerSummaryAsync(UInt64.Parse(i))).Data;
var playerBansResponseData = (await steamInterface.GetPlayerBansAsync(UInt64.Parse(i))).Data;
IReadOnlyCollection <FriendModel> playerFriendsResponseData = null;
if (playerSummaryResponseData.ProfileVisibility == Steam.Models.SteamCommunity.ProfileVisibility.Public)
{
playerFriendsResponseData = (await steamInterface.GetFriendsListAsync(UInt64.Parse(i))).Data;
}
batchQuerybuilder.AppendSqlCommand(new MySqlCommand($"UPDATE FamilyRpServerAccess.ParsedSteamAccounts SET SteamCreated = '{playerSummaryResponseData.AccountCreatedDate}',RowUpdated = NOW()," +
$"SteamName = '{MySqlHelper.EscapeString(UTF8toASCII(playerSummaryResponseData.Nickname))}'," +
$"SteamVisibility = '{playerSummaryResponseData.ProfileVisibility}'," +
$"NumSteamFriends = {(playerFriendsResponseData != null ? playerFriendsResponseData.Count : 0)}," +
$"SteamBans = {playerBansResponseData.First().NumberOfGameBans + (playerBansResponseData.First().CommunityBanned ? 1 : 0) + playerBansResponseData.First().NumberOfVACBans}," +
$"isParsed = 1 " +
$"WHERE SteamId = {i};"));
AuditLog(null, "Steam", "Parsed", "", i, batchQuerybuilder);
}
catch (Exception ex)
{
Console.WriteLine($"Could not fetch Steam ID {i}: {ex}");
}
}
}
}
/// <summary>
/// Will call steam API to update user details
/// </summary>
public async void UpdateUser(object sender, RoutedEventArgs e)
{
CurrentUser currentUser = new CurrentUser();
var steamInterface = new SteamUser(APIKey);
var playerSummaryResponse = await steamInterface.GetPlayerSummaryAsync(userKey);
var playerSummaryData = playerSummaryResponse.Data;
currentUser.AvatarUrl = playerSummaryResponse.Data.AvatarFullUrl;
Debug.Print("AVATAR: " + currentUser.AvatarUrl);
currentUser.CreationDate = playerSummaryResponse.Data.AccountCreatedDate;
currentUser.ProfileUrl = playerSummaryResponse.Data.ProfileUrl;
var accountCreationDate = playerSummaryData.AccountCreatedDate;
var nickname = playerSummaryData.Nickname;
Debug.Print("Account creation date: " + accountCreationDate.ToString());
Debug.Print("Username: "******"Friend: " + friend.SteamId.ToString());
}
var userStats = new SteamUserStats(APIKey);
var steamStats = new SteamApps(APIKey);
AvatarImage.Source = new BitmapImage(new Uri(currentUser.AvatarUrl));
UserNameText.Text = "Username: "******"Account creation date: " + currentUser.CreationDate;
File.Delete("SavedUser" + username + ".xml");
SaveSerializeObject <CurrentUser>(currentUser, "SavedUser" + username + ".xml");
}
/// <summary>
/// Gets a Steam user's <see cref="PlayerSummaryModel"/>
/// </summary>
/// <param name="steamId"></param>
/// <returns></returns>
public static PlayerSummaryModel GetSteamUserSummary(ulong steamId)
{
return(steamUserInterface.GetPlayerSummaryAsync(steamId).GetAwaiter().GetResult().Data);
}
private static async Task MakeCall()
{
Log.Information("Making call");
if (s_SpotifyToken.IsExpired())
{
Log.Debug("Spotify token expired... Refreshing");
await RefreshSpotifyToken();
}
var playbackContext = await s_SpotifyAPI.GetPlaybackAsync();
var summary = await s_SteamAPI.GetPlayerSummaryAsync(s_SteamId);
if (playbackContext?.HasError() != false)
{
Log.Warning("playbackContext is null or has a error");
if (playbackContext.Error is not null)
{
Log.Warning(playbackContext.Error.ToString());
}
}
// Spotify music is playing?
var isPlayingSpotify = playbackContext?.IsPlaying == true && playbackContext.Item != null;
if (isPlayingSpotify)
{
var audios = await s_VKAPI.Audio.SearchAsync(new()
{
SearchOwn = false,
PerformerOnly = false,
Count = 1,
Query = $"{Extensions.GetArtists(playbackContext.Item.Artists)} {playbackContext.Item.Name}"
});
string vkFullAudio;
if (audios?.Any() == false)
{
Log.Debug("Didn't found a music in VK");
Log.Debug("Trying translit to russian");
audios = await s_VKAPI.Audio.SearchAsync(new()
{
SearchOwn = false,
PerformerOnly = false,
Count = 1,
Query = $"{Transliteration.LatinToCyrillic(Extensions.GetArtists(playbackContext.Item.Artists))} {playbackContext.Item.Name}"
});
var audio = audios.FirstOrDefault();
vkFullAudio = audio is not null ? $"{audio.OwnerId}_{audio.Id}" : string.Empty;
}
else
{
var audio = audios[0];
vkFullAudio = $"{audio.OwnerId}_{audio.Id}";
}
if (!string.IsNullOrEmpty(vkFullAudio))
{
Log.Debug($"Found music in VK {vkFullAudio}");
if (s_VKAudioId == vkFullAudio)
{
Log.Debug("Old VkAudio is equals to new.. Skipping");
return;
}
s_VKAudioId = vkFullAudio;
await s_VKAPI.Audio.SetBroadcastAsync(vkFullAudio);
return;
}
Log.Debug("Didn't found a music in VK");
Log.Debug($"Searched: {playbackContext.Item.Name}");
}
else if (!string.IsNullOrEmpty(s_VKAudioId))
{
Log.Debug("Set not listening");
s_VKAudioId = string.Empty;
await s_VKAPI.Audio.SetBroadcastAsync();
}
// Steam playing game
var gameNameSteam = summary.Data?.PlayingGameName;
// Steam user is online
var isOnlineSteam = summary.Data?.UserStatus is UserStatus.Online;
var sb = new StringBuilder();
if (isPlayingSpotify)
{
sb.Append(s_StringLocalizer["Spotify", new[] { Extensions.GetArtists(playbackContext.Item.Artists), playbackContext.Item.Name,
Extensions.GetTime(playbackContext.Item.DurationMs, playbackContext.ProgressMs) }]);
}
else
{
sb.Append(s_StringLocalizer["SpotifyNothing"]);
}
sb.Append(s_StringLocalizer["Steam",
new[] { string.IsNullOrEmpty(gameNameSteam) ? isOnlineSteam ? "в онлайне" : "в оффлайне" : gameNameSteam }]);
if (!(isPlayingSpotify || !string.IsNullOrEmpty(gameNameSteam)))
{
sb.Append(s_StringLocalizer["AFK"]);
}
var status = sb.ToString();
Log.Verbose(status);
if (s_VKStatus == status)
{
Log.Debug("Old status is equals to new. Skip the updating");
return;
}
s_VKStatus = status;
await s_VKAPI.Status.SetAsync(s_VKStatus);
}
public async Task <PlayerSummaryModel> GetUserSummary(ulong userSteamId)
{
var response = await _user.GetPlayerSummaryAsync(userSteamId);
return(response.Data);
}
private static async void OnTimerTicked(object sender, ElapsedEventArgs e)
{
if (Global.Client == null) //Ensures the Discord Client is running before the timer begins
{
Console.WriteLine("Timer Ticked before Client was ready");
return;
}
//Console.WriteLine("Timer Cycle Complete");
try
{
if (count == 0) //On the first cycle of the timer get critical information and store it in the database
{
foreach (var guild in Global.Client.Guilds) //For every server currently running the bot
{
foreach (var user in guild.Users) //For every user in each server
{
string userID = user.Id.ToString(); //Retrieve userID
string steamID = null;
while (steamID == null && !user.IsBot)
{
steamID = DataStorage.getSteamID(userID).Result; //Use userID to access users steam ID in the database
}
if (!user.IsBot && userID != null) //If the user is not a bot and the user exists
{
var gameResponse = steamInterface.GetPlayerSummaryAsync(Convert.ToUInt64(steamID));
string game = gameResponse.Result.Data.PlayingGameName;
if (game == null)
{
game = "none";
}
DataStorage.setNowPlaying(userID, game); //Set the nowPlaying value in the database for this user to the game received from the Steam API
}
}
}
}
else
{
foreach (var guild in Global.Client.Guilds) //For each server running the bot
{
foreach (var chan in guild.TextChannels) //For each channel in each server
{
if (chan.Name == "general") //Find the channel named general and assign its ID to a variable channel
{
channel = chan;
}
}
foreach (var user in guild.Users) //For each user in the server
{
//Retrieve the users steam ID from the database
string userID = user.Id.ToString();
string steamID = null;
while (steamID == null && !user.IsBot)
{
steamID = DataStorage.getSteamID(userID).Result;
}
//If the user is not a bot
if (!user.IsBot)
{
//Get the data from the Steam API for the game that the current Steam ID is playing
var gameResponse = steamInterface.GetPlayerSummaryAsync(Convert.ToUInt64(steamID));
string game = gameResponse.Result.Data.PlayingGameName;
string gameID = gameResponse.Result.Data.PlayingGameId;
var store = steamStoreIntferace.GetStoreAppDetailsAsync(Convert.ToUInt32(gameID));
string imageURL = store.Result.HeaderImage;
if (game == null)
{
game = "none";
}
string checkGame = DataStorage.getNowPlaying(userID); //Gets the nowPlaying value from the database
//If the game in the current users row for nowPlaying in the database does not match the report from the Steam API
//A change has occured and the user is now playing a game so create an embed and post it to the channel as an alert.
if (game.Trim() != checkGame.Trim())
{
embed.WithTitle(user.Username + " Is Now Playing: " + game);
embed.WithColor(0, 173, 238);
if (imageURL == null)
{
game = "none";
gameID = "none";
imageURL = "none";
}
DataStorage.setNowPlaying(userID, game);
if (game != "none")
{
embed.WithImageUrl(imageURL);
//await channel.SendMessageAsync("", false, embed);
}
}
}
}
}
}
count = 1; //Increments the count variable to ensure the initial check does not happen twice.
}
catch (Exception exc)
{
}
}
public async Task <string> GetUserName(ulong steamId)
{
var rs = await m_interface.GetPlayerSummaryAsync(steamId);
return(rs.Data.Nickname);
}
public async Task <string> SteamAvatarUrl(ulong steamId)
{
var response = await _steamUser.GetPlayerSummaryAsync(steamId);
return(response.Data?.AvatarFullUrl);
}
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!");
}
}
}
}
public async Task <string> ProcessCommandAsync(string inputMessage)
{
if (inputMessage == "!steam")
{
return("!steam [command] [username] to use various Steam commands. Valid commands are 'id', 'user', 'bans', 'friends', 'achievements'.");
}
else if (inputMessage.StartsWith("!steam"))
{
var splitParsedMessage = inputMessage.Split(' ');
string steamCommand = splitParsedMessage[1];
string steamCommandParameter = splitParsedMessage[2];
await steamIdContainer.ResolveAsync(steamCommandParameter);
ulong steamId = steamIdContainer.To64Bit();
if (steamCommand == "id")
{
return($"Steam ID for {steamCommandParameter} is {steamId}");
}
else if (steamCommand == "user")
{
var steamUser = await steamUserInterface.GetPlayerSummaryAsync(steamId);
string response = $"Steam profile for {steamCommandParameter} is {steamUser.Data.ProfileUrl} . Account created on: {steamUser.Data.AccountCreatedDate.ToShortDateString()}. User status is: {steamUser.Data.UserStatus}.";
if (!string.IsNullOrWhiteSpace(steamUser.Data.PlayingGameName))
{
response += $" Currently playing: {steamUser.Data.PlayingGameName}.";
}
return(response);
}
else if (steamCommand == "bans")
{
var steamBans = await steamUserInterface.GetPlayerBansAsync(steamId);
// let's just look at the first ban for now
var ban = steamBans.Data.ToList()[0];
string banMessage = $"{steamCommandParameter} has {ban.NumberOfGameBans} game bans and {ban.NumberOfVACBans} VAC bans. Community banned: {ban.CommunityBanned}. VAC banned: {ban.VACBanned}. Economy banned: {ban.EconomyBan}.";
if (ban.NumberOfGameBans > 0 || ban.NumberOfVACBans > 0)
{
banMessage += $" Days since last ban: {ban.DaysSinceLastBan}.";
}
return(banMessage);
}
else if (steamCommand == "friends")
{
var steamFriends = await steamUserInterface.GetFriendsListAsync(steamId);
return($"{steamCommandParameter} has {steamFriends.Data.Count} friends");
}
else if (steamCommand == "achievements")
{
var appId = uint.Parse(splitParsedMessage[3]);
var steamAchievements = await steamUserStatsInterface.GetPlayerAchievementsAsync(appId, steamId);
var completedAchievements = steamAchievements.Data.Achievements.Where(x => x.Achieved == 1);
return($"{steamCommandParameter} has {completedAchievements.Count()} achievements in {steamAchievements.Data.GameName}");
}
else if (steamCommand == "players")
{
var appId = uint.Parse(splitParsedMessage[2]);
var steamPlayers = await steamUserStatsInterface.GetNumberOfCurrentPlayersForGameAsync(appId);
var gameName = games[appId];
return($"{gameName} has {steamPlayers.Data} current players");
}
else if (steamCommand == "level")
{
var steamLevel = await playerServiceInterface.GetSteamLevelAsync(steamId);
return($"{steamCommandParameter} is level {steamLevel.Data} on Steam");
}
else if (steamCommand == "badges")
{
var steamBadges = await playerServiceInterface.GetBadgesAsync(steamId);
return($"{steamCommandParameter} is level {steamBadges.Data.PlayerLevel} which required {steamBadges.Data.PlayerXpNeededCurrentLevel} XP. {steamCommandParameter} has {steamBadges.Data.PlayerXp} XP and needs {steamBadges.Data.PlayerXpNeededToLevelUp} XP to level up.");
}
else if (steamCommand == "recent")
{
var recentGames = await playerServiceInterface.GetRecentlyPlayedGamesAsync(steamId);
var gameList = recentGames.Data.RecentlyPlayedGames.Select(x => $"{x.Name} (Total: {Math.Round((double)x.PlaytimeForever / 60, 1)} hrs, 2 Wks: {Math.Round((double)x.Playtime2Weeks / 60, 1)} hrs)");
string joinedGameList = string.Join(", ", gameList);
string response = $"{steamCommandParameter} has played {recentGames.Data.TotalCount} games in the last 2 weeks: {joinedGameList}.";
return(response);
}
else if (steamCommand == "news")
{
var appId = uint.Parse(splitParsedMessage[2]);
var gameName = games[appId];
var news = await steamNewsInterface.GetNewsForAppAsync(appId, 1);
var recentNews = news.Data.NewsItems.ToList()[0];
return($"Here's the latest news for {gameName}. Author: {recentNews.Author}, Title: {recentNews.Title}, Url: {recentNews.Url} .");
}
}
return(string.Empty);
}
public async Task <PlayerSummaryModel> GetPlayerSummary(ulong id) => await _caches[PlayerSummaryCacheKey].AddOrGetExisting(id.ToString(), async() => (await SteamUser.GetPlayerSummaryAsync(id))?.Data);
