private async void AddWarning(ICommandContext context, IGuildUser userWarned)
{
using (var db = new NinjaBotEntities())
{
var warnings = db.Warnings.Where(w => w.ServerId == (long)context.Guild.Id && w.UserWarnedId == (long)userWarned.Id).FirstOrDefault();
if (warnings != null)
{
warnings.NumWarnings = warnings.NumWarnings + 1;
}
else
{
db.Warnings.Add(new Warnings
{
ServerId = (long)context.Guild.Id,
ServerName = context.Guild.Name,
UserWarnedId = (long)userWarned.Id,
UserWarnedName = userWarned.Username,
IssuerId = (long)context.User.Id,
IssuerName = context.User.Username,
TimeIssued = DateTime.Now,
NumWarnings = 1
});
}
await db.SaveChangesAsync();
}
}
public async Task ForceGreetingClear([Remainder] long serverId)
{
ServerGreeting greetingInfo = null;
using (var db = new NinjaBotEntities())
{
greetingInfo = db.ServerGreetings.Where(g => g.DiscordGuildId == serverId).FirstOrDefault();
}
if (greetingInfo != null)
{
try
{
using (var db = new NinjaBotEntities())
{
db.Remove(db.ServerGreetings.Where(g => g.DiscordGuildId == serverId).FirstOrDefault());
await db.SaveChangesAsync();
}
await _cc.Reply(Context, "Cleared!");
}
catch (Exception ex)
{
await _cc.Reply(Context, $"Error clearing greeting -> [{ex.Message}]");
}
}
else
{
await _cc.Reply(Context, $"No association found for [{serverId}]!");
}
}
private static async Task LogCommandUsage(SocketCommandContext context, IResult result)
{
var request = new Request();
if (context.Channel is IGuildChannel)
{
request.ServerID = (long)context.Guild.Id;
request.ServerName = context.Guild.Name;
System.Console.WriteLine($"+[{System.DateTime.Now.ToString("t")}] User: {context.User.Username} Guild: {context.Guild.Name} -> {context.Message.Content}");
}
else
{
System.Console.WriteLine($"+[{System.DateTime.Now.ToString("t")}] User: {context.User.Username} -> {context.Message.Content}");
}
request.ChannelId = (long)context.Channel.Id;
request.ChannelName = context.Channel.Name;
request.UserId = (long)context.User.Id;
request.Command = context.Message.Content;
request.UserName = context.User.Username;
request.Success = true;
request.RequestTime = DateTime.Now;
string commandIssued = string.Empty;
if (!result.IsSuccess)
{
request.Success = false;
request.FailureReason = result.ErrorReason;
}
using (var db = new NinjaBotEntities())
{
db.Requests.Add(request);
await db.SaveChangesAsync();
}
}
public async Task AddWoWResource([Remainder] string args = null)
{
if (args != null)
{
try
{
int argCount = args.Split(',').Count();
if (argCount == 4)
{
using (var db = new NinjaBotEntities())
{
db.WowResources.Add(new WowResources
{
ClassName = args.Split(',')[0].Trim(),
Specialization = args.Split(',')[1].Trim(),
Resource = args.Split(',')[2].Trim(),
ResourceDescription = args.Split(',')[3].Trim(),
});
await db.SaveChangesAsync();
}
}
}
catch (Exception ex)
{
await _cc.Reply(Context, $"Error adding resource: [{ex.Message}]");
}
}
}
public async Task GetClassicGuild()
{
var sb = new StringBuilder();
var embed = new EmbedBuilder();
WowClassicGuild wowClassicGuild = null;
embed.Title = $"[{Context.Guild.Name}] WoW Classic Guild Association";
embed.ThumbnailUrl = Context.Guild.IconUrl;
using (var db = new NinjaBotEntities())
{
wowClassicGuild = db.WowClassicGuild.Where(g => g.ServerId == (long)Context.Guild.Id).FirstOrDefault();
}
if (wowClassicGuild != null)
{
sb.AppendLine($"**Guild Name:** {wowClassicGuild.WowGuild}");
sb.AppendLine($"**Realm:** {wowClassicGuild.WowRealm}");
sb.AppendLine($"**Region:** {wowClassicGuild.WowRegion}");
}
else
{
sb.AppendLine($"There is no guild associated to this server!");
sb.AppendLine("Placeholder for help text");
}
embed.WithColor(0, 255, 155);
embed.Description = sb.ToString();
await _cc.Reply(Context, embed);
}
private static bool CheckGiphyEnabled(ICommandContext context)
{
bool isEnabled = false;
string serverName = string.Empty;
var guildInfo = context.Guild;
if (guildInfo == null)
{
serverName = context.User.Username;
}
else
{
serverName = context.Guild.Name;
}
using (var db = new NinjaBotEntities())
{
var giphySettings = db.Giphy.FirstOrDefault(g => g.ServerName == serverName);
if (giphySettings != null)
{
if ((bool)giphySettings.GiphyEnabled)
{
isEnabled = true;
}
}
}
return(isEnabled);
}
private async Task WordFinder(SocketMessage messageDetails)
{
await Task.Run(async() =>
{
var message = messageDetails as SocketUserMessage;
if (!messageDetails.Author.IsBot)
{
List <NinjaBotCore.Database.WordList> serverWordList = null;
using (var db = new NinjaBotEntities())
{
SocketGuild guild = (message.Channel as SocketGuildChannel)?.Guild;
serverWordList = db.WordList.Where(w => w.ServerId == (long)guild.Id).ToList();
}
bool wordFound = false;
foreach (var singleWord in serverWordList)
{
foreach (var content in messageDetails.Content.ToLower().Split(' '))
{
if (singleWord.Word.ToLower().Contains(content))
{
wordFound = true;
}
}
}
if (wordFound)
{
await messageDetails.DeleteAsync();
}
}
});
}
public async Task GetLogsClassic()
{
var embed = new EmbedBuilder();
var sb = new StringBuilder();
int maxReturn = 2;
WowClassicGuild wowClassicGuild = null;
using (var db = new NinjaBotEntities())
{
wowClassicGuild = db.WowClassicGuild.Where(g => g.ServerId == (long)Context.Guild.Id).FirstOrDefault();
}
if (wowClassicGuild != null)
{
var guildLogs = await _wclLogsApi.GetReportsFromGuildClassic(wowClassicGuild.WowGuild, wowClassicGuild.WowRealm, wowClassicGuild.WowRegion);
if (guildLogs.Count > 0)
{
sb.AppendLine();
for (int i = 0; i <= (guildLogs.Count) && i <= maxReturn; i++)
{
sb.AppendLine($"[__**{guildLogs[i].title}** **/** **{guildLogs[i].zoneName}**__]({guildLogs[i].reportURL})");
sb.AppendLine($"\t:timer: Start time: **{_wclLogsApi.UnixTimeStampToDateTime(guildLogs[i].start).ToLocalTime()}**");
sb.AppendLine($"\t:stopwatch: End time: **{_wclLogsApi.UnixTimeStampToDateTime(guildLogs[i].end).ToLocalTime()}**");
sb.AppendLine($"\t:pencil2: Created by [**{guildLogs[i].owner}**]");
sb.AppendLine();
}
_logger.LogInformation($"Sending logs to {Context.Channel.Name}, requested by {Context.User.Username}");
embed.Title = $":1234: __Logs for **{wowClassicGuild.WowGuild}** on **{wowClassicGuild.WowRealm}**__:1234: ";
embed.Description = sb.ToString();
embed.WithColor(0, 255, 100);
await _cc.Reply(Context, embed);
}
}
}
public string FindAchievements(Character armoryInfo)
{
StringBuilder cheevMessage = new StringBuilder();
List <FindWowCheeve> findCheeves = null;
var completedCheeves = armoryInfo.achievements.achievementsCompleted;
using (var db = new NinjaBotEntities())
{
findCheeves = db.FindWowCheeves.ToList();
}
if (findCheeves != null)
{
foreach (int achievement in completedCheeves)
{
var findMe = findCheeves.Where(f => f.AchId == achievement).FirstOrDefault();
if (findMe != null)
{
var matchedCheeve = WowApi.Achievements.Where(c => c.id == findMe.AchId).FirstOrDefault();
if (matchedCheeve != null)
{
cheevMessage.AppendLine($":white_check_mark: {matchedCheeve.name}");
}
}
}
}
return(cheevMessage.ToString());
}
private async Task PerformLogCheck(List <LogMonitoring> logWatchList, bool flip, WowClassicGuild guild)
{
try
{
var watchGuild = logWatchList.Where(w => w.ServerId == guild.ServerId).FirstOrDefault();
if (watchGuild != null)
{
if (watchGuild.MonitorLogs)
{
List <Reports> logs = null;
logs = await GetReportsFromGuildClassic(guildName : guild.WowGuild, realm : guild.WowRealm.Replace("'", ""), region : guild.WowRegion, isList : true, flip : flip);
if (flip)
{
flip = false;
}
else
{
flip = true;
}
if (logs != null)
{
var latestLog = logs[0];
DateTime startTime = UnixTimeStampToDateTime(latestLog.start);
//System.Console.WriteLine($"local id [{watchGuild.ClassicReportId}] -> remote id [{latestLog.id}] for [{guild.WowGuild}] on [{guild.WowRealm}].");
if (latestLog.id != watchGuild.ClassicReportId)
{
using (var db = new NinjaBotEntities())
{
var latestForGuild = db.LogMonitoring.Where(l => l.ServerId == guild.ServerId).FirstOrDefault();
latestForGuild.LatestLogClassic = startTime;
latestForGuild.ClassicReportId = latestLog.id;
await db.SaveChangesAsync();
}
ISocketMessageChannel channel = _client.GetChannel((ulong)watchGuild.ChannelId) as ISocketMessageChannel;
if (channel != null)
{
_logger.LogInformation($"Posting log for [{guild.WowGuild}] on [{guild.WowRealm}] for server [{guild.ServerName}]");
var embed = new EmbedBuilder();
embed.Title = $"New log found for [{guild.WowGuild}]!";
StringBuilder sb = new StringBuilder();
sb.AppendLine($"[__**{latestLog.title}** **/** **{latestLog.zoneName}**__]({latestLog.reportURL})");
sb.AppendLine($"\t:timer: Start time: **{UnixTimeStampToDateTime(latestLog.start).ToLocalTime()}**");
sb.AppendLine($"\t:pencil2: Created by [**{latestLog.owner}**]");
sb.AppendLine();
embed.Description = sb.ToString();
embed.WithColor(new Color(0, 0, 255));
await channel.SendMessageAsync("", false, embed.Build());
}
}
}
}
}
}
catch (Exception ex)
{
//_logger.LogError($"Error checking for logs [{guild.WowGuild}]:[{guild.WowRealm}]:[{guild.WowRealm}]! -> [{ex.Message}]");
}
}
public async Task SetLatestRaid(Zones zone)
{
var currentTier = new CurrentRaidTier();
currentTier.WclZoneId = zone.id;
currentTier.RaidName = zone.name;
using (var db = new NinjaBotEntities())
{
var curRaid = db.CurrentRaidTier.FirstOrDefault();
if (curRaid == null)
{
await db.CurrentRaidTier.AddAsync(new CurrentRaidTier
{
WclZoneId = currentTier.WclZoneId,
RaidName = currentTier.RaidName
});
}
else
{
curRaid.WclZoneId = currentTier.WclZoneId;
curRaid.RaidName = currentTier.RaidName;
}
await db.SaveChangesAsync();
}
WarcraftLogs.CurrentRaidTier = currentTier;
}
//if (Context.Channel is IDMChannel)
//{
// await ReplyAsync("DM");
//}
//else if (Context.Channel is IGuildChannel)
//{
// await ReplyAsync("Channel");
//}
public async Task SetGuildBotChannelAsync(ulong channelId, string channelName, ulong userId, string userName, string guildName, ulong guildId)
{
await Task.Run(async() =>
{
using (var db = new NinjaBotEntities())
{
var currentChannel = db.ChannelOutputs.FirstOrDefault(o => o.ServerId == (long)guildId);
if (currentChannel == null)
{
var createChannel = new ChannelOutput
{
ChannelId = (long)channelId,
ChannelName = channelName,
ServerId = (long)guildId,
ServerName = guildName,
SetById = (long)userId,
SetByName = userName,
SetTime = DateTime.Now
};
db.ChannelOutputs.Add(createChannel);
}
else
{
currentChannel.ChannelId = (long)channelId;
currentChannel.ChannelName = channelName;
currentChannel.ServerId = (long)guildId;
currentChannel.ServerName = guildName;
currentChannel.SetById = (long)userId;
currentChannel.SetByName = userName;
currentChannel.SetTime = DateTime.Now;
}
await db.SaveChangesAsync();
}
});
}
public async Task SetPartition([Remainder] string args = null)
{
var embed = new EmbedBuilder();
embed.Title = "Parition setter for NinjaBot";
int?partition = int.Parse(args.Trim());
try
{
if (partition != null)
{
using (var db = new NinjaBotEntities())
{
var curTier = db.CurrentRaidTier.FirstOrDefault();
curTier.Partition = partition;
await db.SaveChangesAsync();
}
}
embed.Description = $"Parition set to {partition}";
}
catch (Exception ex)
{
_logger.LogError($"Error setting partition -> [{ex.Message}]");
embed.Description = "Error setting parition!";
}
await _cc.Reply(Context, embed);
WarcraftLogs.CurrentRaidTier.Partition = partition;
}
public async Task AddWord([Remainder] string word)
{
var sb = new StringBuilder();
using (var db = new NinjaBotEntities())
{
var words = db.WordList.Where(w => w.ServerId == (long)Context.Guild.Id).ToList();
bool wordFound = false;
foreach (var singleWord in words)
{
if (singleWord.Word.ToLower().Contains(word.ToLower()))
{
wordFound = true;
}
}
if (wordFound)
{
sb.AppendLine($"[{word}] is already in the list!");
}
else
{
sb.AppendLine($"Adding [{word}] to the list!");
db.Add(new WordList
{
ServerId = (long)Context.Guild.Id,
ServerName = Context.Guild.Name,
Word = word,
SetById = (long)Context.User.Id
});
await db.SaveChangesAsync();
}
}
await _cc.Reply(Context, sb.ToString());
}
private void MigrateOldReports()
{
List <LogMonitoring> logWatchList = null;
try
{
using (var db = new NinjaBotEntities())
{
logWatchList = db.LogMonitoring.ToList();
foreach (var entry in logWatchList.Where(r => !string.IsNullOrEmpty(r.ReportId)))
{
var oldReportId = entry.ReportId;
var oldLatestDate = entry.LatestLog;
entry.LatestLogRetail = oldLatestDate;
entry.RetailReportId = oldReportId;
entry.ReportId = string.Empty;
System.Console.WriteLine($"Updating [{entry.ServerName}]...");
db.SaveChanges();
}
}
}
catch (Exception ex)
{
//_logger.LogError($"Error getting log watch list -> [{ex.Message}]");
}
}
public async Task ListWoWResource([Remainder] string args = null)
{
List <WowResources> resources = null;
using (var db = new NinjaBotEntities())
{
resources = db.WowResources.Where(r => r.ClassName.ToLower().Contains(args)).ToList();
}
if (resources != null)
{
var embed = new EmbedBuilder();
embed.Title = $"WoW Resource List Search: [{args}]";
foreach (var resource in resources)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Class: [{resource.ClassName}]");
sb.AppendLine($"Specialization: [{resource.Specialization}]");
sb.AppendLine($"Resource: [{resource.Resource}]");
sb.AppendLine($"ResourceDescription: [{resource.ResourceDescription}]");
embed.AddField(new EmbedFieldBuilder
{
Name = $"{resource.Id}",
Value = sb.ToString()
});
}
await _cc.Reply(Context, embed);
}
}
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}");
}
}
public async Task SetStats(string name, string platform)
{
try
{
string channel = Context.Channel.Name;
string userName = Context.User.Username;
ulong discordUserId = Context.User.Id;
StringBuilder sb = new StringBuilder();
using (var db = new NinjaBotEntities())
{
switch (platform.ToLower())
{
case "steam":
{
var getPlayer = await _rlsClient.GetPlayerAsync(RlsPlatform.Steam, name);
try
{
var addUser = new RlStat();
var rlUser = db.RlStats.Where(r => (ulong)r.DiscordUserID == discordUserId).FirstOrDefault();
if (rlUser == null)
{
addUser.DiscordUserName = userName;
addUser.DiscordUserID = (long)discordUserId;
addUser.SteamID = long.Parse(getPlayer.UniqueId);
addUser.DiscordUserID = (long)Context.User.Id;
addUser.Platform = RlsPlatform.Steam.ToString();
addUser.RlPlayerName = getPlayer.DisplayName;
db.RlStats.Add(addUser);
}
else
{
rlUser.SteamID = long.Parse(getPlayer.UniqueId);
rlUser.DiscordUserID = (long)discordUserId;
rlUser.RlPlayerName = getPlayer.DisplayName;
rlUser.Platform = RlsPlatform.Steam.ToString();
}
db.SaveChanges();
sb.AppendLine($"{Context.User.Mention}, you've associated [**{getPlayer.DisplayName}**(steam)] 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());
}
break;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
}
}
public async Task PopulateLogs()
{
{
List <WowGuildAssociations> guildList = null;
List <LogMonitoring> logWatchList = null;
try
{
using (var db = new NinjaBotEntities())
{
guildList = db.WowGuildAssociations.ToList();
logWatchList = db.LogMonitoring.ToList();
}
}
catch (Exception ex)
{
_logger.LogError($"Error getting guild/logwatch list -> [{ex.Message}]");
}
if (guildList != null)
{
foreach (var guild in guildList)
{
try
{
var watchGuild = logWatchList.Where(w => w.ServerId == guild.ServerId).FirstOrDefault();
if (watchGuild != null)
{
if (watchGuild.MonitorLogs)
{
//System._logger.LogInformation($"YES! Watch logs on {guild.ServerName}!");
var logs = await _logsApi.GetReportsFromGuild(guildName : guild.WowGuild, realm : guild.WowRealm.Replace("'", ""), region : guild.WowRegion);
if (logs != null)
{
var latestLog = logs[logs.Count - 1];
DateTime startTime = _wowApi.UnixTimeStampToDateTime(latestLog.start);
{
using (var db = new NinjaBotEntities())
{
var latestForGuild = db.LogMonitoring.Where(l => l.ServerId == guild.ServerId).FirstOrDefault();
latestForGuild.LatestLogRetail = startTime;
latestForGuild.RetailReportId = latestLog.id;
await db.SaveChangesAsync();
}
//System._logger.LogInformation($"Updated [{watchGuild.ServerName}] -> [{latestLog.id}] [{latestLog.owner}]!");
}
}
}
}
}
catch (Exception ex)
{
_logger.LogError($"Error checking for logs! -> [{ex.Message}]");
}
}
}
}
}
public AwaySystem getAwayUser(string discordUserName)
{
var awayUser = new AwaySystem();
using (var db = new NinjaBotEntities())
{
awayUser = db.AwaySystem.Where(a => a.UserName == discordUserName).FirstOrDefault();
}
return(awayUser);
}
private ServerGreeting GetGreeting(SocketGuildUser user)
{
ServerGreeting shouldGreet = null;
var guildId = user.Guild.Id;
using (var db = new NinjaBotEntities())
{
shouldGreet = db.ServerGreetings.Where(g => g.DiscordGuildId == (long)guildId).FirstOrDefault();
}
return shouldGreet;
}
private async Task <Warnings> GetWarning(ICommandContext context, IGuildUser userWarned)
{
Warnings warning = null;
using (var db = new NinjaBotEntities())
{
warning = db.Warnings.Where(w => w.ServerId == (long)context.Guild.Id && w.UserWarnedId == (long)userWarned.Id).FirstOrDefault();
}
return(warning);
}
public async Task AskQuestion([Remainder] string args)
{
var embed = new EmbedBuilder();
Random r = new Random();
var answers = new List <C8Ball>();
using (var db = new NinjaBotEntities())
{
answers = db.C8Ball.ToList();
if (answers == null)
{
answers.Add(new C8Ball
{
AnswerId = 0,
Answer = "No! (cant access DB)",
Color = "Red"
});
}
}
var answer = answers[r.Next(answers.Count())];
string answerText = string.Empty;
if (answer != null)
{
answerText = answer.Answer;
switch (answer.Color.ToLower())
{
case "yellow":
{
embed.WithColor(new Color(255, 255, 0));
break;
}
case "red":
{
embed.WithColor(new Color(255, 0, 0));
break;
}
case "green":
{
embed.WithColor(new Color(0, 128, 0));
break;
}
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("** **");
sb.AppendLine($"**{answerText}**");
sb.AppendLine("** **\n");
embed.Description = sb.ToString();
}
embed.ThumbnailUrl = Context.User.GetAvatarUrl();
embed.Title = $":crystal_ball: Ninja 8-Ball: (**{args}**) :crystal_ball:";
await _cc.Reply(Context, embed);
}
public async Task ChangeParting([Remainder] string args = null)
{
var embed = new EmbedBuilder();
StringBuilder sb = new StringBuilder();
if (!string.IsNullOrEmpty(args))
{
embed.Title = $"Parting message change for {Context.Guild.Name}";
sb.AppendLine("New message:");
sb.AppendLine(args);
using (var db = new NinjaBotEntities())
{
try
{
var guildGreetingInfo = db.ServerGreetings.Where(g => g.DiscordGuildId == (long)Context.Guild.Id).FirstOrDefault();
if (guildGreetingInfo != null)
{
guildGreetingInfo.PartingMessage = args.Trim();
guildGreetingInfo.SetById = (long)Context.User.Id;
guildGreetingInfo.SetByName = Context.User.Username;
guildGreetingInfo.TimeSet = DateTime.Now;
}
else
{
db.ServerGreetings.Add(new ServerGreeting
{
DiscordGuildId = (long)Context.Guild.Id,
PartingMessage = args.Trim(),
SetById = (long)Context.User.Id,
SetByName = Context.User.Username,
TimeSet = DateTime.Now
});
}
await db.SaveChangesAsync();
}
catch (Exception)
{
embed.Title = $"Error changing message";
sb.AppendLine($"{Context.User.Mention},");
sb.AppendLine($"I've encounted an error, please contact the owner for help.");
}
}
}
else
{
embed.Title = $"Error changing message";
sb.AppendLine($"{Context.User.Mention},");
sb.AppendLine($"Please provided a message!");
}
embed.Description = sb.ToString();
embed.WithColor(new Color(0, 255, 0));
embed.ThumbnailUrl = Context.Guild.IconUrl;
await _cc.Reply(Context, embed);
}
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 RemoveChar(string charName = null)
{
var embed = new EmbedBuilder();
var sb = new StringBuilder();
if (charName != null)
{
try
{
WowMChar charMatch = null;
using (var db = new NinjaBotEntities())
{
charMatch = db.WowMChar.Where(d => d.DiscordUserId == (long)Context.User.Id && d.ServerId == (long)Context.Guild.Id && charName.ToLower() == d.CharName.ToLower()).FirstOrDefault();
if (charMatch != null)
{
db.WowMChar.Remove(charMatch);
await db.SaveChangesAsync();
sb.AppendLine($"Character [**{charMatch.CharName}**] successfully removed!");
embed.WithColor(0, 255, 0);
}
else
{
sb.AppendLine($"Could not find [**{charName}**]!");
embed.WithColor(255, 0, 0);
}
}
}
catch
{
}
}
else
{
embed.WithColor(255, 0, 0);
sb.AppendLine("Please specify a character name!");
using (var db = new NinjaBotEntities())
{
var chars = db.WowMChar.Where(d => d.DiscordUserId == (long)Context.User.Id && d.ServerId == (long)Context.Guild.Id).ToList();
if (chars != null && chars.Count > 0)
{
sb.AppendLine($"Your character's names are:");
foreach (var character in chars)
{
sb.AppendLine($":white_medium_small_square: [**{character.CharName}**]");
}
}
}
}
embed.ThumbnailUrl = Context.User.GetAvatarUrl();
embed.Title = "Character Removal";
embed.Description = sb.ToString();
await _cc.Reply(Context, embed);
}
private PrefixList GetPrefix(long serverId)
{
PrefixList prefix = null;
using (var db = new NinjaBotEntities())
{
prefix = db.PrefixList.Where(p => p.ServerId == serverId).FirstOrDefault();
}
return(prefix);
}
public async Task <List <WowAuctions> > GetAuctionsByRealm(string realmName, string regionName = "us")
{
AuctionsModel.AuctionFile file;
AuctionsModel.Auctions a = new AuctionsModel.Auctions();
AuctionsModel.Auction[] auctions;
string url = string.Empty;
string fileContent = string.Empty;
DateTime? latestTimeStampFromDb;
List <WowAuctions> dbAuctions = new List <WowAuctions>();
List <WowAuctions> returnAuction = new List <WowAuctions>();
url = $"/auction/data/{realmName}?locale={regionName}";
file = JsonConvert.DeserializeObject <AuctionsModel.AuctionFile>(GetAPIRequest(url, regionName));
string fileURL = file.files[0].url;
DateTime lastModified = UnixTimeStampToDateTime(file.files[0].lastModified);
using (var db = new NinjaBotEntities())
{
dbAuctions = db.WowAuctions.Where(r => r.RealmName.ToLower() == realmName.ToLower()).ToList();
latestTimeStampFromDb = dbAuctions.OrderBy(t => t.DateModified).Take(1).Select(l => l.DateModified).FirstOrDefault();
//db.Database.CurrentTransaction.Dispose();
//db.Database.Connection.Close();
}
if (dbAuctions.Count > 0)
{
if (lastModified > latestTimeStampFromDb)
{
fileContent = GetAPIRequest(fileURL, true);
}
else
{
return(dbAuctions);
}
}
else
{
fileContent = GetAPIRequest(fileURL, true);
}
a = JsonConvert.DeserializeObject <AuctionsModel.Auctions>(fileContent);
auctions = a.auctions;
auctions[0].fileDate = lastModified;
await AddAuctionsToDb(realmName, a, auctions, lastModified);
using (var db = new NinjaBotEntities())
{
string slugName = a.realms[0].slug;
returnAuction = db.WowAuctions.Where(w => w.RealmSlug == slugName).ToList();
//db.Database.Connection.Close();
}
return(returnAuction);
}
private async void ResetWarnings(Warnings warning)
{
using (var db = new NinjaBotEntities())
{
var currentWarning = db.Warnings.Where(w => w.Warnid == warning.Warnid).FirstOrDefault();
if (currentWarning != null)
{
db.Warnings.Remove(currentWarning);
await db.SaveChangesAsync();
}
}
}
public async Task <RlStat> GetRlUserInfo(bool ps)
{
string userName = Context.User.Username;
StringBuilder sb = new StringBuilder();
RlStat rlUser = null;
using (var db = new NinjaBotEntities())
{
rlUser = db.RlStats.FirstOrDefault(r => r.DiscordUserName == userName);
}
return(rlUser);
}
