public async Task SetStats(string name)
        {
            try
            {
                using (var db = new NinjaBotEntities())
                {
                    string        channel    = Context.Channel.Name;
                    string        userName   = Context.User.Username;
                    StringBuilder sb         = new StringBuilder();
                    string        rlUserName = name;

                    if (Uri.IsWellFormedUriString(rlUserName, UriKind.RelativeOrAbsolute))
                    {
                        rlUserName = rlUserName.TrimEnd('/');
                        rlUserName = rlUserName.Substring(rlUserName.LastIndexOf('/') + 1);
                    }

                    SteamModel.Player fromSteam = _steam.GetSteamPlayerInfo(rlUserName);
                    if (string.IsNullOrEmpty(fromSteam.steamid))
                    {
                        sb.AppendLine($"{Context.User.Mention}, Please specify a steam username/full profile URL to link with your Discord username!");
                        await _cc.Reply(Context, sb.ToString());

                        return;
                    }
                    try
                    {
                        var addUser = new RlStat();
                        var rlUser  = db.RlStats.Where(r => r.DiscordUserName == userName).FirstOrDefault();
                        if (rlUser == null)
                        {
                            addUser.DiscordUserName = userName;
                            addUser.SteamID         = long.Parse(fromSteam.steamid);
                            addUser.DiscordUserID   = (long)Context.User.Id;
                            db.RlStats.Add(addUser);
                        }
                        else
                        {
                            rlUser.SteamID       = long.Parse(fromSteam.steamid);
                            rlUser.DiscordUserID = (long)Context.User.Id;
                            //rl.setUserName(userName, fromSteam.steamid);
                        }
                        db.SaveChanges();
                        sb.AppendLine($"{Context.User.Mention}, you've associated [**{fromSteam.personaname}**] with your Discord name!");
                        await _cc.Reply(Context, sb.ToString());
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"RL Stats: Error setting name -> {ex.Message}");
                        sb.AppendLine($"{Context.User.Mention}, something went wrong, sorry :(");
                        await _cc.Reply(Context, sb.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{ex.Message}");
            }
        }
        private async Task <RlUserStat> GetStatsFromDb(SteamModel.Player fromSteam)
        {
            RlUserStat rlUserStats = null;
            long       steamId     = long.Parse(fromSteam.steamid);

            using (var db = new NinjaBotEntities())
            {
                rlUserStats = db.RlUserStats.Where(r => r.SteamID == steamId).FirstOrDefault();
            }
            return(rlUserStats);
        }
        public async Task GetStats(string name)
        {
            StringBuilder sb = new StringBuilder();

            //SteamModel.Player fromSteam = _steam.getSteamPlayerInfo(name);\ 
            if (name.Contains("/:") && Uri.IsWellFormedUriString(name, UriKind.RelativeOrAbsolute))
            {
                name = name.TrimEnd('/');
                name = name.Substring(name.LastIndexOf('/') + 1);
                SteamModel.Player fromSteam = _steam.GetSteamPlayerInfo(name);
                try
                {
                    EmbedBuilder embed = await RlEmbedApi(fromSteam);

                    await _cc.Reply(Context, embed);
                }
                catch (Exception ex)
                {
                    await _cc.Reply(Context, "Sorry, something went wrong!");

                    Console.WriteLine(ex.Message);
                }
                return;
            }

            var searchResults = await _rlsClient.SearchPlayerAsync(name);

            if (searchResults.TotalResults > 0)
            {
                try
                {
                    EmbedBuilder embed = await RlEmbedApi(searchResults.Data[0]);

                    //await InsertStats(searchResults.data[0]);
                    await _cc.Reply(Context, embed);
                }
                catch (Exception ex)
                {
                    await _cc.Reply(Context, "Sorry, something went wrong!");

                    Console.WriteLine(ex.Message);
                }
                return;
            }
            else
            {
                sb.AppendLine($"Unable to find steam user for steam name/id: {name}!");
                await _cc.Reply(Context, sb.ToString());

                return;
            }
        }
Exemplo n.º 4
0
 public SteamModel.Player GetSteamPlayerInfo(string lookupPlayer)
 {
     SteamModel.Player p = new SteamModel.Player();
     try
     {
         long steamID = 0;
         if (lookupPlayer.Length == 17)
         {
             long.TryParse(lookupPlayer, out steamID);
             Console.WriteLine($"{steamID}");
             if (steamID != 0)
             {
                 try
                 {
                     GetProfileInfoBySteamID(steamID);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine($"{ex.Message}");
                 }
             }
         }
         else
         {
             SteamModel.VanitySteam v;
             v = GetSteamIDbyVanityURL(lookupPlayer);
             if (v.success == 1)
             {
                 p = GetProfileInfoBySteamID(long.Parse(v.steamid));
                 Console.WriteLine(p.steamid);
             }
             else
             {
             }
         }
     }
     catch (Exception ex)
     {
         Console.WriteLine($"{ex.Message}");
     }
     return(p);
 }
        private async Task InsertStats(List <RocketLeagueStats> stats, SteamModel.Player fromSteam)
        {
            long steamId = long.Parse(fromSteam.steamid);

            using (var db = new NinjaBotEntities())
            {
                var statAdd      = new RlUserStat();
                var getStat      = db.RlUserStats.Where(s => s.SteamID == steamId).FirstOrDefault();
                var doubles      = stats.Where(s => s.Title == "Doubles 2v2").FirstOrDefault();
                var duel         = stats.Where(s => s.Title == "Duel 1v1").FirstOrDefault();
                var soloStandard = stats.Where(s => s.Title == "Solo Standard 3v3").FirstOrDefault();
                var rankedThrees = stats.Where(s => s.Title == "Standard 3v3").FirstOrDefault();
                var unranked     = stats.Where(s => s.Title == "Unranked").FirstOrDefault();

                if (getStat == null)
                {
                    if (doubles != null)
                    {
                        statAdd.Ranked2v2 = doubles.MMR.ToString();
                    }
                    else
                    {
                        statAdd.Ranked2v2 = "0";
                    }
                    if (duel != null)
                    {
                        statAdd.RankedDuel = duel.MMR.ToString();
                    }
                    else
                    {
                        statAdd.RankedDuel = "0";
                    }
                    if (soloStandard != null)
                    {
                        statAdd.RankedSolo = soloStandard.MMR.ToString();
                    }
                    else
                    {
                        statAdd.RankedSolo = "0";
                    }
                    if (rankedThrees != null)
                    {
                        statAdd.Ranked3v3 = rankedThrees.MMR.ToString();
                    }
                    else
                    {
                        statAdd.Ranked3v3 = "0";
                    }
                    if (unranked != null)
                    {
                        statAdd.Unranked = unranked.MMR.ToString();
                    }
                    else
                    {
                        statAdd.Unranked = "0";
                    }
                    statAdd.SteamID = steamId;
                    db.RlUserStats.Add(statAdd);
                }
                else
                {
                    if (doubles != null)
                    {
                        getStat.Ranked2v2 = doubles.MMR.ToString();
                    }

                    if (duel != null)
                    {
                        getStat.RankedDuel = duel.MMR.ToString();
                    }

                    if (soloStandard != null)
                    {
                        getStat.RankedSolo = soloStandard.MMR.ToString();
                    }

                    if (rankedThrees != null)
                    {
                        getStat.Ranked3v3 = rankedThrees.MMR.ToString();
                    }

                    if (unranked != null)
                    {
                        getStat.Unranked = unranked.MMR.ToString();
                    }
                    getStat.SteamID = steamId;
                }
                await db.SaveChangesAsync();
            }
        }
        private async Task <EmbedBuilder> RlEmbedApi(SteamModel.Player fromSteam)
        {
            long steamId = 0;

            long.TryParse(fromSteam.steamid, out steamId);
            var stats = await _rlsClient.GetPlayerAsync(RlsPlatform.Steam, steamId.ToString());

            var           embed = new EmbedBuilder();
            StringBuilder sb    = new StringBuilder();

            embed.Title        = $"Stats for [{fromSteam.personaname}]";
            embed.ThumbnailUrl = fromSteam.avatarfull;
            embed.WithColor(new Color(0, 255, 0));
            embed.WithAuthor(new EmbedAuthorBuilder
            {
                Name    = $"{Context.User.Username}",
                IconUrl = $"{Context.User.GetAvatarUrl()}"
            });
            var rankingsFromObject = stats.RankedSeasons.FirstOrDefault(x => x.Key == RlsSeason.Seven);

            foreach (var rank in rankingsFromObject.Value)
            {
                //var rankInfo = (SeasonStats)rank.Value;
                //FormatStatInfo(sb, rank, rankInfo);
            }

            /*
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Season 7",
             *  Value = $"{sb.ToString()}",
             *  IsInline = false
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Shots",
             *  Value = $"{stats.stats.shots}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Goals",
             *  Value = $"{stats.stats.goals}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "MVPs",
             *  Value = $"{stats.stats.mvps}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Assists",
             *  Value = $"{stats.stats.assists}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Saves",
             *  Value = $"{stats.stats.saves}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Wins",
             *  Value = $"{stats.stats.wins}",
             *  IsInline = true
             * });
             * embed.AddField(new EmbedFieldBuilder
             * {
             *  Name = "Stats Provided By:",
             *  Value = $"{stats.profileUrl}",
             *  IsInline = false
             * });
             */
            return(embed);
        }