/// <summary>
/// Processes the query ID and returns the results
/// </summary>
/// <param name="id">The Query id</param>
/// <param name="Database">The stats database connection</param>
/// <returns></returns>
protected List <Player> GetTopFromQuery(int id, StatsDatabase Database)
{
List <Player> Players = new List <Player>(5);
var Rows = Database.Query(IndexQueries[id]);
for (int i = 0; i < 5; i++)
{
if (i < Rows.Count)
{
double ds = Double.Parse(Rows[i]["value"].ToString());
string Val = ((ds % 1) != 0) ? Math.Round(ds, 4).ToString() : FormatNumber(ds);
Players.Add(new Player
{
Pid = Int32.Parse(Rows[i]["id"].ToString()),
Name = Rows[i]["name"].ToString(),
Rank = Int32.Parse(Rows[i]["rank"].ToString()),
Value = Val
});
}
else
{
Players.Add(new Player {
Name = ""
});
}
}
return(Players);
}
private void ShowTopics(string nick, string channel, CommandArgs command, bool showDebugInfo)
{
Logger.Log(this, "Showing topics for " + nick);
var user = StatsDatabase.GetUserByNickname(nick);
var topics = StatsDatabase.FindTopics(user.Id, channel);
if (topics == null)
{
command.Reply($"could not find any IRC data by {nick}. Did you spell their name correctly?");
return;
}
string topicString;
if (showDebugInfo)
{
topicString = string.Join(", ", topics.Take(20).Select(pair => $"\x02{pair.Name}\x02 ({pair.UserCount}/{pair.GlobalCount}: {pair.Score:N2})"));
}
else
{
topicString = string.Join(", ", topics.Take(20).Select(pair => pair.Name));
}
command.Reply($"words associated with {nick}: {topicString}");
}
/// <summary>
/// Returns a bool stating whether the criteria for this award is met for a givin player
/// </summary>
/// <param name="Pid">The player ID</param>
/// <param name="Level">The award level if the criteria is met</param>
/// <returns></returns>
public bool CriteriaMet(int Pid, StatsDatabase Driver, ref int Level)
{
// Get the award count (or level for badges) for this award
string Query = "SELECT COALESCE(max(level), 0) FROM awards WHERE id=@P0 AND awd=@P1";
int AwardCount = Driver.ExecuteScalar <int>(Query, Pid, AwardId);
bool IsRibbon = (AwardId > 3000000);
// Can only recieve ribbons once in a lifetime, so return false if we have it already
if (IsRibbon && AwardCount > 0)
{
return(false);
}
// Medals and Badges can receive multiple times (Badges are award level, not count)
if (!IsRibbon)
{
Level = AwardCount + 1;
}
// Loop through each criteria and see if we have met the criteria
foreach (AwardCriteria Criteria in Criterias)
{
// Build the query. We always use a count() or sum() to return a sortof bool.
string Where = Criteria.Where.Replace("###", Level.ToString());
Query = String.Format("SELECT {0} FROM {1} WHERE id={2} AND {3}", Criteria.Field, Criteria.Table, Pid, Where);
// If we dont meet the expected result, the criteria is unmet, no use continuing
if (Driver.ExecuteScalar <int>(Query) < Criteria.ExpectedResult)
{
return(false);
}
}
return(true);
}
public override void HandleRequest()
{
// NOTE: The HttpServer will handle the DbConnectException
using (Database = new StatsDatabase())
{
int Pid = 0;
List <Dictionary <string, object> > Rows;
// Setup Params
if (Client.Request.QueryString.ContainsKey("pid"))
{
Int32.TryParse(Client.Request.QueryString["pid"], out Pid);
}
// Fetch Player
Rows = Database.Query("SELECT rank FROM player WHERE id=@P0", Pid);
if (Rows.Count == 0)
{
Response.WriteResponseStart(false);
Response.WriteFreeformLine("Player Doesnt Exist!");
Client.Response.Send();
return;
}
// Reset
Database.Execute("UPDATE player SET chng=0, decr=0 WHERE id=@P0", Pid);
Response.WriteResponseStart();
Response.WriteFreeformLine(String.Format("Cleared rank notification {0}", Pid));
Response.Send();
}
}
private void GenerateRandomQuote(MessageEvent ev, List <string> words)
{
var message = ev.Message;
if (message.Action)
{
message = message.Edit("*" + message.Sender.Nickname + " " + message.Body + "*");
}
if (ControlVariables.SnagNextLine)
{
ControlVariables.SnagNextLine = false;
StatsDatabase.Snag(message);
ev.ReturnMessageCallback("Snagged line on request.");
return;
}
if (ControlVariables.SnagNextLineBy != null && ControlVariables.SnagNextLineBy == message.Sender.Nickname)
{
ControlVariables.SnagNextLineBy = null;
StatsDatabase.Snag(message);
ev.ReturnMessageCallback("Snagged line on request.");
return;
}
TryTakeQuote(ev, words);
}
/// <summary>
/// Clears the stats database of all data
/// </summary>
private void ClearStatsBtn_Click(object sender, EventArgs e)
{
if (MessageBox.Show(
"Are you sure you want to clear the stats database? This will ERASE ALL stats data, and cannot be recovered!",
"Confirm",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Warning) == DialogResult.OK)
{
try
{
using (StatsDatabase Database = new StatsDatabase())
{
Database.Truncate();
}
Notify.Show("Database Successfully Cleared!", "All stats have successfully been cleared.", AlertType.Success);
}
catch (Exception E)
{
MessageBox.Show(
"An error occured while clearing the stats database!\r\n\r\nMessage: " + E.Message,
"Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
}
}
}
public override void HandleRequest()
{
// NOTE: The HttpServer will handle the DbConnectException
using (Database = new StatsDatabase())
{
int Pid = 0;
// Setup Params
if (Client.Request.QueryString.ContainsKey("pid"))
{
Int32.TryParse(Client.Request.QueryString["pid"], out Pid);
}
// Fetch Player
var Rows = Database.Query("SELECT rank, chng, decr FROM player WHERE id=@P0", Pid);
if (Rows.Count == 0)
{
Response.WriteResponseStart(false);
Response.WriteHeaderLine("asof", "err");
Response.WriteDataLine(DateTime.UtcNow.ToUnixTimestamp(), "Player Doesnt Exist");
Response.Send();
return;
}
// Output status... chng set to 1 shows the Promotion Announcement, whereas decr shows the Demotion Announcement
Response.WriteResponseStart();
Response.WriteHeaderLine("rank", "chng", "decr");
Response.WriteDataLine(Rows[0]["rank"], Rows[0]["chng"], Rows[0]["decr"]);
Response.Send();
// Reset
Database.Execute("UPDATE player SET chng=0, decr=0 WHERE id=@P0", Pid);
}
}
private void ShowIndex()
{
// Check the cache file
if (!base.CacheFileExpired("rankings_index", 30))
{
base.SendCachedResponse("rankings_index");
return;
}
// Create our model
RankingsModel Model = new RankingsModel(Client);
// NOTE: The HttpServer will handle the DbConnectException
using (StatsDatabase Database = new StatsDatabase())
{
// Loop through and add each index catagories, and its players
for (int i = 0; i < IndexCatagories.Count; i++)
{
Model.Stats.Add(new RankingStats
{
Name = IndexCatagories[i].Key,
Desc = IndexCatagories[i].Value,
UrlName = ActionNames[i],
TopPlayers = GetTopFromQuery(i, Database)
});
}
}
// Send response
base.SendTemplateResponse("rankings_index", typeof(RankingsModel), Model, "Rankings");
}
/// <summary>
/// This method imports a list of .Bak files into the database
/// </summary>
/// <param name="BakFiles">A list of Backfiles to import into the database</param>
/// <param name="Database">The opened database connection</param>
private void ImportFromBakup(string[] BakFiles, StatsDatabase Database)
{
// Clear old database records
TaskForm.Progress.Report(new TaskProgressUpdate("Removing old stats data"));
Database.Truncate();
// Let the database update itself
Thread.Sleep(500);
// Begin transaction
using (DbTransaction Transaction = Database.BeginTransaction())
{
// import each table
foreach (string file in BakFiles)
{
// Get table name
string table = Path.GetFileNameWithoutExtension(file);
TaskForm.Progress.Report(new TaskProgressUpdate("Processing stats table: " + table));
// Import table data
try
{
// Sqlite kinda sucks... no import methods
if (Database.DatabaseEngine == DatabaseEngine.Sqlite)
{
string[] Lines = File.ReadAllLines(file);
foreach (string line in Lines)
{
string[] Values = line.Split('\t');
Database.Execute(
String.Format("INSERT INTO {0} VALUES({1})", table, "\"" + String.Join("\", \"", Values) + "\"")
);
}
}
else
{
Database.Execute(String.Format("LOAD DATA LOCAL INFILE '{0}' INTO TABLE {1};", file.Replace('\\', '/'), table));
}
}
catch (Exception Ex)
{
// Show exception error
using (ExceptionForm Form = new ExceptionForm(Ex, false))
{
Form.Message = String.Format("Failed to import data into table {0}!{2}{2}Error: {1}", table, Ex.Message, Environment.NewLine);
DialogResult Result = Form.ShowDialog();
// Rollback!
TaskForm.Progress.Report(new TaskProgressUpdate("Rolling back stats data"));
Transaction.Rollback();
return;
}
}
}
// Commit the transaction
Transaction.Commit();
}
}
public override void HandleRequest()
{
int Pid = 0;
int Unlock = 0;
List <Dictionary <string, object> > Rows;
// Setup Params
if (Request.QueryString.ContainsKey("pid"))
{
Int32.TryParse(Request.QueryString["pid"], out Pid);
}
if (Request.QueryString.ContainsKey("id"))
{
Int32.TryParse(Request.QueryString["id"], out Unlock);
}
// Make sure we have valid parameters
if (Pid == 0 || Unlock == 0)
{
Response.WriteResponseStart(false);
Response.WriteHeaderLine("asof", "err");
Response.WriteDataLine(DateTime.UtcNow.ToUnixTimestamp(), "Invalid Syntax!");
Response.Send();
return;
}
// NOTE: The HttpServer will handle the DbConnectException
using (Database = new StatsDatabase())
{
// Fetch Player
Rows = Database.Query("SELECT availunlocks, usedunlocks FROM player WHERE id=@P0", Pid);
if (Rows.Count == 0)
{
Response.WriteResponseStart(false);
Response.WriteHeaderLine("asof", "err");
Response.WriteDataLine(DateTime.UtcNow.ToUnixTimestamp(), "Player Doesnt Exist");
Response.Send();
return;
}
// Update Unlock, setting its state to 's' (unlocked)
Database.Execute("UPDATE unlocks SET state = 's' WHERE id = @P0 AND kit = @P1", Pid, Unlock);
// Update players used and avail unlock counts
Database.Execute("UPDATE player SET availunlocks = @P0, usedunlocks = @P1 WHERE id = @P2",
int.Parse(Rows[0]["availunlocks"].ToString()) - 1,
int.Parse(Rows[0]["usedunlocks"].ToString()) + 1,
Pid
);
// Send Response
Response.WriteResponseStart();
Response.WriteHeaderLine("response");
Response.WriteDataLine("OK");
Response.Send();
}
}
public override void Use(CommandArgs command)
{
var messages = StatsDatabase.GetMessages();
var usage = messages.SelectMany(m => WordTools.GetWords(m.Message)).GroupBy(w => w).ToDictionary(g => g.Key, g => g.Count());
StatsDatabase.IncrementWords(usage);
command.Reply("done.");
}
/// <summary>
/// Imports a Player XML Sheet from the specified path
/// </summary>
/// <param name="XmlPath">The full path to the XML file</param>
public static void ImportPlayerXml(string XmlPath)
{
// Connect to database first!
using (StatsDatabase Driver = new StatsDatabase())
{
// Load elements
XDocument Doc = XDocument.Load(new FileStream(XmlPath, FileMode.Open, FileAccess.Read));
XElement Info = Doc.Root.Element("Info");
XElement TableData = Doc.Root.Element("TableData");
// Make sure player doesnt already exist
int Pid = Int32.Parse(Info.Element("Pid").Value);
if (Driver.PlayerExists(Pid))
{
throw new Exception(String.Format("Player with PID {0} already exists!", Pid));
}
// Begin Transaction
using (DbTransaction Transaction = Driver.BeginTransaction())
{
try
{
// Loop through tables
foreach (XElement Table in TableData.Elements())
{
// Loop through Rows
foreach (XElement Row in Table.Elements())
{
InsertQueryBuilder QueryBuilder = new InsertQueryBuilder(Table.Name.LocalName, Driver);
foreach (XElement Col in Row.Elements())
{
if (Col.Name.LocalName == "name")
{
QueryBuilder.SetField(Col.Name.LocalName, Col.Value.UnescapeXML());
}
else
{
QueryBuilder.SetField(Col.Name.LocalName, Col.Value);
}
}
QueryBuilder.Execute();
}
}
// Commit Transaction
Transaction.Commit();
}
catch
{
Transaction.Rollback();
throw;
}
}
}
}
public override void HandleMessage(MessageEvent ev)
{
if (!Client.IncludeChannel(ev.Message.Channel))
{
Logger.Log(null, "Dropping message because its channel should be excluded.");
return;
}
var message = ev.Message;
// Can't save statistics if we don't have a DB connection!
if (StatsDatabase.ConnectionState == ConnectionState.Closed)
{
return;
}
// Add the message to the chat log
StatsDatabase.AddMessage(message);
var userId = message.Sender.DbUser.Id;
// Increment actions/lines for the user
if (message.Action)
{
StatsDatabase.IncrementActions(userId);
}
else
{
StatsDatabase.IncrementLineCount(userId);
}
// Increment words for the user
var words = WordTools.GetWords(message.Body);
StatsDatabase.IncrementWordCount(userId, words.Count);
// Increment global line/word count
StatsDatabase.IncrementVar("global_line_count");
StatsDatabase.IncrementVar("global_word_count", words.Count);
// Update emoticon usage
foreach (var word in words.Where(word => Emoticons.List.Contains(word)))
{
StatsDatabase.IncrementEmoticon(word, userId);
}
// Process individual words
foreach (var word in words)
{
ProcessWord(message, word, userId);
}
// Quote grabbing
GenerateRandomQuote(ev, words);
ProcessRandomEvents(ev);
}
private ChatUser Bind(ChatUser user)
{
if (StatsDatabase.ConnectionState != ConnectionState.Open)
{
return(user);
}
var dbUser = StatsDatabase.UpsertUser(user);
user.BindDbUser(dbUser);
return(user);
}
/// <summary>
/// Reset Unlocks Button Click Event
/// </summary>
private void ResetUnlocksBtn_Click(object sender, EventArgs e)
{
try
{
// Create New Player Unlock Data
StringBuilder Query = new StringBuilder("INSERT INTO unlocks VALUES ");
// Normal unlocks
for (int i = 11; i < 100; i += 11)
{
Query.AppendFormat("({0}, {1}, 'n'), ", Pid, i);
}
// Sf Unlocks
for (int i = 111; i < 556; i += 111)
{
Query.AppendFormat("({0}, {1}, 'n')", Pid, i);
if (i != 555)
{
Query.Append(", ");
}
}
// Do driver queries
using (StatsDatabase Driver = new StatsDatabase())
using (DbTransaction T = Driver.BeginTransaction())
{
try
{
// Perform queries
Driver.Execute("DELETE FROM unlocks WHERE id = " + Pid);
Driver.Execute("UPDATE player SET usedunlocks = 0 WHERE id = " + Pid);
Driver.Execute(Query.ToString());
T.Commit();
// Notify user
Notify.Show("Player Unlocks Have Been Reset", "This player will be able to select his new unlocks upon logging in.", AlertType.Success);
}
catch
{
T.Rollback();
throw;
}
}
}
catch (DbConnectException Ex)
{
HttpServer.Stop();
ExceptionForm.ShowDbConnectError(Ex);
this.Close();
}
}
/// <summary>
/// Reset stats button click event
/// </summary>
private async void ResetStatsBtn_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Are you sure you want to reset players stats?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
try
{
TaskForm.Show(this, "Reset Player Stats", "Reseting Player \"" + Player["name"] + "\"'s Stats", false);
await Task.Run(() =>
{
// Delete the players
using (StatsDatabase Driver = new StatsDatabase())
{
// Delete old player statistics
Driver.DeletePlayer(Pid, TaskForm.Progress);
// Insert a new player record
Driver.Execute(
"INSERT INTO player(id, name, country, joined, clantag, permban, isbot) VALUES(@P0, @P1, @P2, @P3, @P4, @P5, @P6)",
Pid, Player["name"], Player["country"], Player["joined"], Player["clantag"], Player["permban"], Player["isbot"]
);
}
});
// Reload player
LoadPlayer();
Notify.Show("Player Stats Reset Successfully!", "Operation Successful", AlertType.Success);
}
catch (DbConnectException Ex)
{
HttpServer.Stop();
ExceptionForm.ShowDbConnectError(Ex);
TaskForm.CloseForm();
this.Close();
return;
}
catch (Exception E)
{
// Show exception error
using (ExceptionForm Form = new ExceptionForm(E, false))
{
Form.Message = String.Format("Failed to reset player stats!{1}{1}Error: {0}", E.Message, Environment.NewLine);
Form.ShowDialog();
}
}
finally
{
// Close task form
TaskForm.CloseForm();
}
}
}
/// <summary>
/// Import Stats Button Click Event
/// </summary>
private void ImportBtn_Click(object sender, EventArgs e)
{
// Make sure PID text box is a valid PID
if (!Validator.IsValidPID(PidTextBox.Text))
{
MessageBox.Show("The player ID entered is NOT a valid PID. Please try again.",
"Validation Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Establist Database connection
try
{
using (StatsDatabase Database = new StatsDatabase())
{
// Make sure the PID doesnt exist already
int Pid = Int32.Parse(PidTextBox.Text);
if (Database.PlayerExists(Pid))
{
MessageBox.Show("The player ID entered already exists.",
"Import Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
// Show Task Form
TaskForm.Show(this, "Import ASP Stats", "Importing ASP Stats...", false, ProgressBarStyle.Blocks, 13);
// Setup the worker
bWorker = new BackgroundWorker();
bWorker.WorkerSupportsCancellation = false;
bWorker.WorkerReportsProgress = true;
// Run Worker
bWorker.DoWork += bWorker_ImportEaStats;
bWorker.ProgressChanged += (s, ea) =>
{
TaskForm.Progress.Report(new TaskProgressUpdate(ea.UserState.ToString(), ea.ProgressPercentage));
};
bWorker.RunWorkerCompleted += bWorker_RunWorkerCompleted;
bWorker.RunWorkerAsync(PidTextBox.Text);
}
}
catch (DbConnectException Ex)
{
ExceptionForm.ShowDbConnectError(Ex);
HttpServer.Stop();
this.Close();
return;
}
}
/// <summary>
/// Adds a server's posted snapshot into the Snapshot Processing Queue, which
/// will process the snapshot as soon as possible. This method is Non-Blocking.
/// </summary>
/// <remarks>
/// Any errors that occur during the actual import of the data will be
/// logged inside the StatsDebug log
/// </remarks>
/// <param name="Data">The snapshot data provided by the server.</param>
/// <param name="ServerAddress">The IP address of the server.</param>
/// <exception cref="UnauthorizedAccessException">
/// Thrown if the Server IP is not authorized to post game data to this server
/// </exception>
/// <exception cref="InvalidDataException">
/// Thrown if the provided Snapshot data is not valid, and cannot be processed
/// </exception>
public static void QueueServerSnapshot(string Data, IPAddress ServerAddress)
{
// Make sure the server is authorized
if (!IsAuthorizedGameServer(ServerAddress))
{
throw new UnauthorizedAccessException("Un-Authorised Gameserver (Ip: " + ServerAddress + ")");
}
// Create the Snapshot Object
Snapshot Snap = new Snapshot(Data, ServerAddress);
// Update this server in the Database
using (StatsDatabase Database = new StatsDatabase())
{
// Try and grab the ID of this server
int id = Database.ExecuteScalar <int>(
"SELECT COALESCE(id, -1), COUNT(id) FROM servers WHERE ip=@P0 AND port=@P1",
ServerAddress, Snap.ServerPort
);
// New server?
if (id < 0)
{
InsertQueryBuilder builder = new InsertQueryBuilder(Database);
builder.SetTable("servers");
builder.SetField("ip", ServerAddress);
builder.SetField("port", Snap.ServerPort);
builder.SetField("prefix", Snap.ServerPrefix);
builder.SetField("name", Snap.ServerName);
builder.SetField("queryport", Snap.QueryPort);
builder.SetField("lastupdate", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
builder.Execute();
}
else // existing
{
UpdateQueryBuilder builder = new UpdateQueryBuilder(Database);
builder.SetTable("servers");
builder.SetField("prefix", Snap.ServerPrefix);
builder.SetField("name", Snap.ServerName);
builder.SetField("queryport", Snap.QueryPort);
builder.SetField("lastupdate", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
builder.AddWhere("id", Comparison.Equals, id);
builder.Execute();
}
}
// Add snapshot to Queue
SnapshotQueue.Enqueue(Snap);
}
private void SetName(string match, bool matchIsUid, string name)
{
User user;
if (matchIsUid)
{
user = StatsDatabase.GetUserById(int.Parse(match));
}
else
{
user = StatsDatabase.GetUserByNickname(match);
}
user.AddressableNameOverride = name.Trim();
StatsDatabase.UpdateUser(user);
}
public override void Use(CommandArgs command)
{
var parser = new CommandParser(new Operation()
.AddKey("rows", 3, 'r')
.AddFlag("tables", 't')
.AddRestArgument(string.Empty));
var parsed = parser.Parse(command.FullArgument);
if (parsed.Flags["tables"])
{
command.Reply($"the following tables are available: {string.Join(", ", StatsDatabase.GetTableNames())}");
return;
}
if (string.IsNullOrWhiteSpace(parsed.RestArgument))
{
InformUsage(command);
return;
}
var table = StatsDatabase.ExecuteQuery(parsed.RestArgument);
if (table.Rows.Count == 0)
{
command.Reply("done.");
return;
}
var maxRows = parsed.GetKey <int>("rows");
var columnLengths = GetColumnLengths(table, maxRows);
if (Client.Capabilities.AllowsMultilineMessages)
{
var dividerLength = columnLengths.Sum() + (columnLengths.Length - 1) * " | ".Length;
var divider = string.Concat(Enumerable.Repeat('=', dividerLength));
command.ReturnMessage($"{Frm.MMultiline}{PrintHeader(table, columnLengths)}\n{divider}\n{PrintBody(table, columnLengths, maxRows)}{Frm.MMultiline}");
}
else
{
var header = $"{Frm.U}{PrintHeader(table, columnLengths)}{Frm.U}";
var lines = PrintBody(table, columnLengths, maxRows).Split('\n');
command.ReturnMessage(header);
foreach (var line in lines)
{
command.ReturnMessage(line);
}
}
}
/// <summary>
/// Method to be called everytime the HttpStatsServer is started
/// </summary>
public static void Load(StatsDatabase Driver)
{
// Get the lowest Offline PID from the database
var Rows = Driver.Query(
String.Format(
"SELECT COALESCE(MIN(id), {0}) AS min, COALESCE(MAX(id), {0}) AS max FROM player WHERE id < {1}",
DEFAULT_PID, MAX_PID
)
);
int Lowest = Int32.Parse(Rows[0]["min"].ToString());
int Highest = Int32.Parse(Rows[0]["max"].ToString());
AiPid = (Lowest > DEFAULT_PID) ? DEFAULT_PID : Lowest;
PlayerPid = (Highest < DEFAULT_PID) ? DEFAULT_PID : Highest;
}
public override void Use(CommandArgs command)
{
if (command.FullArgument == null)
{
InformUsage(command);
return;
}
var parser = new CommandParser(new Operation()
.AddKey("max-results", 1, 'r')
.AddKey("uid", -1, 'u')
.AddKey("nickname", null, 'n')
.AddRestArgument());
var result = parser.Parse(command.FullArgument);
var numDisplayed = result.GetKey <int>("max-results");
if (numDisplayed > 3 && !Client.Validate(command.Sender))
{
command.Reply("only bot operators may request more than three results.");
return;
}
var uid = result.GetKey <int>("uid");
var nickname = result.Keys["nickname"];
var query = result.RestArgument;
var matches = StatsDatabase.FindLine(query, uid, nickname);
switch (matches.Count)
{
case 0:
command.Reply("no matches found.");
break;
case 1:
command.Reply("1 match found: " + matches[0]);
break;
default:
command.Reply($"{matches.Count} matches ({numDisplayed} displayed):");
foreach (var match in matches.Take(numDisplayed))
{
command.ReturnMessage($"{match}");
}
break;
}
}
private void GetUid(CommandArgs command, OperationResult result)
{
var users = StatsDatabase.GetUsersByNickname(result.Arguments["user"]);
if (users.Length == 0)
{
command.Reply($"I don't know a user with {result.Arguments["user"]} as their primary name");
}
else if (users.Length == 1)
{
command.Reply($"I found the following user for {result.Arguments["user"]}: {users[0]}");
}
else
{
command.Reply($"Multiple matches found for {result.Arguments["user"]}: {string.Join(", ", users.Select(u => u.Id))}");
}
}
public override void Use(CommandArgs command)
{
if (command.Args.Length > 1)
{
var key = command.Args[0];
var value = string.Join(" ", command.Args.Skip(1));
if (value.StartsWith("-"))
{
value = value.Substring(1);
}
StatsDatabase.UpsertMiscData("alias", key, value);
command.Reply($"I've aliased {key} to \"{value}\"");
}
else
{
InformUsage(command);
}
}
public override void Use(CommandArgs command)
{
var search = command.FullArgument;
var searchResults = StatsDatabase.FindQuote(search);
if (searchResults.Count == 0)
{
command.ReturnMessage("No such quote found.");
return;
}
var quoteListBuiler = new StringBuilder();
quoteListBuiler.Append("Multiple quotes found: ");
var max = searchResults.Count > 12 ? 12 : searchResults.Count;
for (var i = 0; i < max; i++)
{
quoteListBuiler.Append("\"");
quoteListBuiler.Append(searchResults[i].Text.Substring(0, 25));
quoteListBuiler.Append("\"");
if (i != max - 1)
{
quoteListBuiler.Append(", ");
}
}
var diff = searchResults.Count - max;
if (diff > 0)
{
quoteListBuiler.Append($" and {diff} more.");
}
if (searchResults.Count > 1)
{
command.Reply(quoteListBuiler.ToString());
return;
}
command.ReturnMessage("The following quote has been featured: \"" + searchResults[0].Text + "\"");
StatsDatabase.SetVar("featured_quote", searchResults[0].Id);
}
public override void HandleRequest()
{
int Pid;
// make sure we have a valid player ID
if (!Request.QueryString.ContainsKey("pid") ||
!Int32.TryParse(Request.QueryString["pid"], out Pid) ||
!Request.QueryString.ContainsKey("nick"))
{
Response.WriteResponseStart(false);
Response.WriteHeaderLine("asof", "err");
Response.WriteDataLine(DateTime.UtcNow.ToUnixTimestamp(), "Invalid Syntax!");
Response.Send();
return;
}
// NOTE: The HttpServer will handle the DbConnectException
using (Database = new StatsDatabase())
{
// Fetch Player
string PlayerNick = Request.QueryString["nick"].Replace("%20", " ");
string CC = (Request.QueryString.ContainsKey("cid")) ? Client.Request.QueryString["cid"] : "";
if (Database.ExecuteScalar <int>("SELECT COUNT(*) FROM player WHERE id=@P0 OR name=@P1", Pid, PlayerNick) > 0)
{
Response.WriteResponseStart(false);
Response.WriteFreeformLine("Player already Exists!");
Response.Send();
return;
}
// Create Player
Database.Execute(
"INSERT INTO player(id, name, country, joined, isbot) VALUES(@P0, @P1, @P2, @P3, 0)",
Pid, PlayerNick, CC, DateTime.UtcNow.ToUnixTimestamp()
);
// Confirm
Response.WriteResponseStart();
Response.WriteFreeformLine("Player Created Successfully!");
Response.Send();
}
}
private void TryTakeQuote(MessageEvent ev, List <string> words)
{
var last = StatsDatabase.GetLastQuotedLine(ev.Message.Sender.DbUser.Id);
if (last.HasValue)
{
if ((DateTime.Now - last.Value).Hours < ConfigManager.Config.Quotes.MinDelayHours)
{
return;
}
}
var snagChance = ConfigManager.Config.Quotes.Chance;
var silenceChance = ConfigManager.Config.Quotes.SilentQuoteChance;
if (words.Count > 6)
{ // Do not snag if the amount of words to be snagged is less than 7
if (rand.NextDouble() <= snagChance)
{
var allowSnagMessage = ConfigManager.Config.Quotes.AllowQuoteNotifications;
var hideSnagMessage = rand.NextDouble() <= silenceChance;
if (!allowSnagMessage || hideSnagMessage)
{ // Check if snag message should be displayed
Logger.Log(this, "Silently snagging this message");
StatsDatabase.Snag(ev.Message);
}
else
{
var randint = rand.Next(snagMessages.Length * 2); // Determine whether to simply say "Snagged!" or use a randomized snag message.
if (randint < snagMessages.Length)
{
TakeQuote(ev, snagMessages[randint]);
}
else
{
TakeQuote(ev, "Snagged!");
}
}
}
}
}
private void ProcessWord(ChatMessage message, string word, int sender)
{
// In order to count word occurrence correctly, all words are transformed to
// lowercase, and all non-latin characters are removed. This is done because
// people commonly say "its" when they mean "it's", and it is very difficult
// to determine which one they meant, so instead, they are considered equal.
var lword = word.ToLower();
var cword = textOnly.Replace(lword, string.Empty);
if (word.StartsWith("http://") || word.StartsWith("https://"))
{
StatsDatabase.IncrementUrl(word, sender, message.Body);
}
else
{
StatsDatabase.IncrementWord(cword);
}
if (WordTools.IsProfanity(lword))
{
StatsDatabase.IncrementProfanities(sender);
}
}
/// <summary>
/// Constructor
/// </summary>
public PlayerSearchForm()
{
InitializeComponent();
// Establish DB connection
try
{
Driver = new StatsDatabase();
}
catch (DbConnectException Ex)
{
HttpServer.Stop();
ExceptionForm.ShowDbConnectError(Ex);
Load += (s, e) => Close(); // Close form
return;
}
// Initialize sorting
SortedCol = DataTable.Columns[1];
SortedCol.HeaderCell.SortGlyphDirection = SortOrder.Ascending;
LimitSelect.SelectedIndex = 2;
}
public override void HandleRequest(MvcRoute Route)
{
// Try and Fetch Player ID
Int32.TryParse(Route.Action, out Pid);
// NOTE: The HttpServer will handle the DbConnectException
using (Database = new StatsDatabase())
{
// Fetch Player
Rows = Database.Query("SELECT * FROM player WHERE id=@P0", Pid);
if (Rows.Count == 0)
{
Client.Response.Redirect("/bf2stats/search");
return;
}
// Load our page based on the param passed
if (Route.Params.Length > 0)
{
if (Route.Params[0] == "rankings")
{
ShowRankings();
}
else if (Route.Params[0] == "history")
{
ShowHistory();
}
else
{
Client.Response.StatusCode = 404;
}
}
else
{
ShowStats();
}
}
}
