public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public)
{
Match expressionMatch = _youtubeRegex.Match(request.Message);
if (expressionMatch.Success)
{
string videoId = expressionMatch.Groups[1].Value;
VideoResponse videoResponse = YouTubeService.GetVideo(new VideoRequest() {VideoId = videoId});
if(videoResponse.Video != null)
{
Response response = request.CreateResponse(ResponseType.Public, videoResponse.Video.Title + " (Views: " + videoResponse.Video.ViewCount.ToString("#,##0") + ")");
ModuleManagementContainer.HandleResponse(response);
}
else
{
Response response = request.CreateResponse(ResponseType.Public, "I had a problem fetching the title of that youtube video, sorry dude.");
ModuleManagementContainer.HandleResponse(response);
}
}
}
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public && request.Message.StartsWith("~AccessToken", StringComparison.OrdinalIgnoreCase))
{
var splitMessage = request.Message.Split(' ');
// We've got an operation.
if (splitMessage.Length > 1)
{
// TODO [Kog 07/23/2011] : We need to fix looking up who requested the token. This mechanism is pretty bad.
// Look up the user who sent the message.
var userToken = AuthenticationManager.ExchangeTokenForConcreteType<IrcUserToken>(request.RequestFrom.User);
var user = AuthenticationManager.FindHostByCloak(userToken.HostMask);
// Handle a user requesting a new access token.
if (splitMessage[1].Equals("request", StringComparison.InvariantCultureIgnoreCase))
{
// Try and pull the TTL for the token out of the args.
var timeToLive = 1;
if (splitMessage.Length > 2)
{
int.TryParse(splitMessage[2], out timeToLive);
}
var accessTokenExpiration = timeToLive == 0 ? DateTime.MaxValue : DateTime.Now.ToUniversalTime().AddDays(timeToLive);
// Generate a new GUID.
var accessToken = Guid.NewGuid();
var accessTokenCreationTime = DateTime.Now.ToUniversalTime();
// Slap it on the user's account.
user.AccessToken = accessToken.ToString();
user.AccessTokenIssueTime = accessTokenCreationTime;
user.AccessTokenExpiration = accessTokenExpiration;
// Update the account.
AuthenticationManager.UpdateHost(user);
// Hand it back.
Reply(request, ResponseType.Private, "Your new access token is {0}.", accessToken);
}
// Handle a user asking for their current access token.
if (splitMessage[1].Equals("display", StringComparison.InvariantCultureIgnoreCase))
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Private,
user.AccessToken == null ? "You have no access token. Please request one." :
String.Format("Your access token is {0} and was generated at {1} UTC. The token will expire at {2} UTC.",
user.AccessToken, user.AccessTokenIssueTime, user.AccessTokenExpiration)));
}
}
else
{
// The user used the command incorrectly.
Reply(request, ResponseType.Private, "Invalid access token request, please consult the help for details.");
}
}
}
public override void HandleRequest(Request request)
{
var messageArray = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (request.RequestSourceType == RequestSourceType.Private
&& request.RequestFrom.AccessLevel >= AccessLevel.Root
&& messageArray[0].Equals("~puppet", StringComparison.OrdinalIgnoreCase)
&& messageArray.Length >= 4)
{
var target = messageArray[2].Trim();
var message = string.Empty;
for (var i = 3; i < messageArray.Length; i++)
{
message += messageArray[i];
message += " ";
}
if (messageArray[1].Equals("say", StringComparison.OrdinalIgnoreCase))
{
var response = request.CreateResponse(ResponseTargetType.Public, ResponseType.Message, false, message);
response.Channel = target;
ModuleManagementContainer.HandleResponse(response);
}
else if (messageArray[1].Equals("do", StringComparison.OrdinalIgnoreCase))
{
var response = request.CreateResponse(ResponseTargetType.Public, ResponseType.Action, false, message);
response.Channel = target;
ModuleManagementContainer.HandleResponse(response);
}
}
}
public override void HandleRequest(Request request)
{
var message = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (request.RequestFrom.AccessLevel >= AccessLevel.Root
&& message[0].Equals("~logging", StringComparison.OrdinalIgnoreCase)
&& message.Length == 2)
{
var levelName = message[1].ToLower();
if (_loggingLevels.ContainsKey(levelName))
{
var loggingLevel = _loggingLevels[levelName];
LoggerManager.GetAllRepositories().ForEach(x =>
{
x.Threshold = loggingLevel;
x.GetCurrentLoggers().ForEach(y => ((Logger)y).Level = loggingLevel);
});
((Hierarchy)log4net.LogManager.GetRepository()).Root.Level = loggingLevel;
XmlConfigurator.Configure(new FileInfo("log4net.xml"));
// You may not actually catch this if you've just set the level to WARN, but if you're doing that type of filtering chances are you don't care anyway.
_logger.InfoFormat("Set logging level to {0}.", loggingLevel.DisplayName);
}
}
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public &&
request.Message.StartsWith("~email", StringComparison.OrdinalIgnoreCase))
{
var splitMessage = request.Message.Split(' ');
// We've got an operation.
if (splitMessage.Length > 1)
{
// Look up the user who sent the message.
var userToken = AuthenticationManager.ExchangeTokenForConcreteType<IrcUserToken>(request.RequestFrom.User);
var user = AuthenticationManager.FindHostByCloak(userToken.HostMask);
// Handle the case when the user wants to set their email.
if (splitMessage[1].Equals("set", StringComparison.InvariantCultureIgnoreCase))
{
// Make sure the user has given us an email.
if (splitMessage.Length > 2)
{
var email = splitMessage[2];
try
{
user.EmailAddress = email;
AuthenticationManager.UpdateHost(user);
Reply(request, ResponseType.Private, "Your email has been set to {0}", email);
}
catch (Exception ex)
{
// Ruh roh, they've violated our unique constraint.
Logger.Warn("Caught an exception trying to set someone's email.", ex);
Reply(request, ResponseType.Private, "Email {0} is already in use.", email);
}
}
else
{
// User hasn't given us an email, barf.
Reply(request, ResponseType.Private, "No email specified, cannot set email address.");
}
}
// Handle the case when the user wants to check their email.
if (splitMessage[1].Equals("display", StringComparison.InvariantCultureIgnoreCase))
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Private,
String.IsNullOrEmpty(user.EmailAddress) ? "You have no email address set."
: String.Format("Your currently set email is {0}.", user.EmailAddress)));
}
}
else
{
// User has given us an invalid request, barf.
Reply(request, ResponseType.Private, "Invalid request, please read the help for email.");
}
}
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public
&& request.Message.Equals("~about", StringComparison.OrdinalIgnoreCase))
{
SendResponse(request);
}
}
/// <summary>
/// Handles responding to a user IFF they have proper access, and the trigger is ~name.
/// </summary>
///
/// <param name="request">A <see cref="Request"/> representing a message sent to the bot.</param>
public override void HandleRequest(Request request)
{
string[] messageArray = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (request.RequestFrom.AccessLevel >= AccessLevel.Public
&& request.RequestType == RequestType.Public
&& messageArray[0].Equals("~"+Name, StringComparison.OrdinalIgnoreCase))
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Public, Phrase));
}
}
/// <summary>
/// Sends a help response for a given module.
/// </summary>
///
/// <param name="module">The module to send information about.</param>
/// <param name="request">The incoming message to respond to.</param>
private void SendHelpResponses(IModule module, Request request)
{
Response response = request.CreateResponse(ResponseType.Private);
response.Message = "Module Name: " + module.Name;
ModuleManagementContainer.HandleResponse(response);
response.Message = "Module Description: " + module.Description;
ModuleManagementContainer.HandleResponse(response);
response.Message = "Module Instructions: " + module.Instructions;
ModuleManagementContainer.HandleResponse(response);
}
public override void HandleRequest(Request request)
{
string[] message = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
// The user must be root, the request must be a 1:1 PRIVMSG and it's gotta be of a known form factor.
if (request.RequestFrom.AccessLevel >= AccessLevel.Root
&& request.RequestType == RequestType.Private
&& message[0].Equals("~users", StringComparison.OrdinalIgnoreCase)
&& (message.Length >= 2 && message.Length <= 5))
{
// users list
if (message[1].Equals("list", StringComparison.OrdinalIgnoreCase) && message.Length == 2)
{
ListUsers(request);
}
// users add hostmask level
if (message[1].Equals("add", StringComparison.OrdinalIgnoreCase) && message.Length == 4)
{
AddUser(message[2], message[3], request);
}
// users del hostmask
if (message[1].Equals("del", StringComparison.OrdinalIgnoreCase) && message.Length == 3)
{
DeleteUser(message[2], request);
}
// TODO: Kog 1/13/2010 - We can probably replace this with something like a nested collection of funcs. Make it funky now.
// users metadata ..
if (message[1].Equals("metadata", StringComparison.OrdinalIgnoreCase) && message.Length == 5)
{
// If they're trying to del the tag, do so.
if (message[2].Equals("del", StringComparison.OrdinalIgnoreCase))
{
DeleteMetaDatumForUser(message[3], message[4], request);
}
else
{
// if they give a key and a value, create or update the tag accordingly.
CreateOrUpdateMetaDatumForUser(message[2], message[3], message[4], request);
}
}
}
}
/// <summary>
/// Attempts to process our search request.
/// </summary>
///
/// <param name="request">Our incoming message.</param>
public override void HandleRequest(Request request)
{
if (request.RequestType == RequestType.Public)
{
string[] messageArray = request.Message.Split(' ');
if (request.Message.StartsWith("~")
&& request.RequestFrom.AccessLevel >= AccessLevel.Public
&& messageArray.Length >= 2
&& messageArray[0].ToLower() == SearchTrigger)
{
string searchTerms = string.Empty;
for (int i = 1; i < messageArray.Length; i++)
{
searchTerms += messageArray[i] + " ";
}
Logger.DebugFormat("{0} - HandleRequest called on for {1} by {2}", Name, request.Message,
request.Addressee ?? request.Nick);
SearchProvider.ExecuteSearch(searchTerms, SearchUrl, x => HandleResults(x, request, searchTerms));
}
else if (messageArray[0].StartsWith(NetworkConnectionInformation.BotNickname))
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public
&& messageArray.Length >= 3
&& messageArray[1].ToLower() == SearchTrigger.Substring(1))
{
string searchTerms = string.Empty;
for (int i = 2; i < messageArray.Length; i++)
{
searchTerms += messageArray[i] + " ";
}
Logger.DebugFormat("{0} - HandleRequest called on for {1} by {2}", Name, request.Message,
request.Addressee ?? request.Nick);
SearchProvider.ExecuteSearch(searchTerms, SearchUrl,
x => HandleResults(x, request, searchTerms));
}
}
}
}
/// <summary>
/// Checks to see if the user has called for a shutdown, and if so what their access level is. If they have the proper permissions we then attempt to parse an
/// optional quit message.
/// </summary>
///
/// <param name="request">Our incoming message.</param>
public override void HandleRequest(Request request)
{
// The user has permission and is indeed requesting a shutdown.
if (request.RequestFrom.AccessLevel >= AccessLevel.Root && request.Message.StartsWith("~shutdown", StringComparison.OrdinalIgnoreCase))
{
// Parse off our quit message.
string message = "No quit message specified.";
int offset = request.Message.IndexOf("~shutdown") + 9;
if (request.Message.Length > offset)
{
message = request.Message.Substring(offset).Trim();
}
BotContext.Shutdown(message);
}
}
/// <summary>
/// See if we want to digest this message, and if so take action.
/// </summary>
///
/// <param name="request">A message</param>
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public)
{
Match expressionMatch = _karmaRegex.Match(request.Message);
if (expressionMatch.Success)
{
String nick = expressionMatch.Groups[1].Value;
String op = expressionMatch.Groups[2].Value;
Response response;
// Make sure the sender isn't messing with their own karma.
if (nick.Equals(request.Nick, StringComparison.OrdinalIgnoreCase) && !String.IsNullOrEmpty(op))
{
response = request.CreateResponse(ResponseType.Public, string.Format("{0}, toggling your own karma is very uncool.", request.Nick));
ModuleManagementContainer.HandleResponse(response);
}
else
{
// Attempt to look the user up.
KarmaItem karma = KarmaDao.FindKarma(nick.ToLower()) ?? new KarmaItem {KarmaLevel = 0, UserName = nick.ToLower()};
// If they're doing anything more than looking...
if (!String.IsNullOrEmpty(op))
{
if (op.Equals("--"))
{
karma.KarmaLevel--;
}
else if (op.Equals("++"))
{
karma.KarmaLevel++;
}
KarmaDao.SaveKarma(karma);
}
response = request.CreateResponse(ResponseType.Public, String.Format("{0} has a karma of {1}", nick, karma.KarmaLevel));
ModuleManagementContainer.HandleResponse(response);
}
}
}
}
private void SendResponse(Request request)
{
string message = string.Format("{0} (V{1}) is the ##csharp irc bot on freenode.net",
NetworkConnectionInformation.BotNickname,
Assembly.GetEntryAssembly().GetName().Version.ToString(2));
Response response = request.CreateResponse(ResponseType.Private, message);
ModuleManagementContainer.HandleResponse(response);
response.Message = "====================================";
ModuleManagementContainer.HandleResponse(response);
response.Message = "IRC: To get help with the bot type '~Help' in private message with the bot.";
ModuleManagementContainer.HandleResponse(response);
response.Message = "Wiki: http://wiki.freenode-csharp.net/wiki/";
ModuleManagementContainer.HandleResponse(response);
response.Message = "====================================";
ModuleManagementContainer.HandleResponse(response);
response.Message = "But there's no sense crying over every mistake. You just keep on trying till you run out of cake.";
ModuleManagementContainer.HandleResponse(response);
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public)
{
string[] messageArray = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (messageArray[0].Equals("~help", StringComparison.OrdinalIgnoreCase))
{
// A user has asked for help, not specifying a module. List what we've got.
if (messageArray.Length == 1)
{
SendHelpResponses(ModuleManagementContainer.Modules.Where(module => module.Name.Equals("Help")).First(), request);
SendModulesListResponse(request);
}
// A user has asked for help regarding a specific module. Attempt to display help for it.
else if (messageArray.Length == 2)
{
string moduleName = messageArray[1];
IModule targetModule = ModuleManagementContainer.Modules.Where(module =>
module.Name.Equals(moduleName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
// We know what that module is!
if (null != targetModule && targetModule.RequiredAccessLevel <= request.RequestFrom.AccessLevel)
{
SendHelpResponses(targetModule, request);
}
// What? What module is that you say? Quick lads, play dumb!
else
{
SendModuleNotFoundResponse(moduleName, request);
}
}
// A user has asked us for something we don't understand. Tell them to try again.
else
{
SendIncorrectRequestSyntaxResponse(request);
SendHelpResponses(ModuleManagementContainer.Modules.Where(module => module.Name.Equals("Help")).First(), request);
SendModulesListResponse(request);
}
}
}
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public)
{
Match expressionMatch = _urbanRegex.Match(request.Message);
if (expressionMatch.Success)
{
bool urlRequested = expressionMatch.Groups[1].Value.Equals("nu", StringComparison.InvariantCultureIgnoreCase);
string term = expressionMatch.Groups[2].Value;
UrbanResponse urbanResponse = UrbanService.Search(new UrbanRequest() {Term = term});
if(urbanResponse != null)
{
if(urbanResponse.Definition.HasValue())
{
Response response = request.CreateResponse(ResponseType.Public, "Definition: " + urbanResponse.Definition.Replace('\r', ' ').Replace('\n', ' '));
ModuleManagementContainer.HandleResponse(response);
}
if(urbanResponse.Example.HasValue())
{
Response response = request.CreateResponse(ResponseType.Public, "Example: " + urbanResponse.Example.Replace('\r', ' ').Replace('\n', ' '));
ModuleManagementContainer.HandleResponse(response);
}
if (urlRequested && urbanResponse.Url.HasValue())
{
Response response = request.CreateResponse(ResponseType.Public, "Url: " + urbanResponse.Url);
ModuleManagementContainer.HandleResponse(response);
}
}
else
{
Response response = request.CreateResponse(ResponseType.Public, "I couldn't find anything with the term '" + term + "', sorry dude.");
ModuleManagementContainer.HandleResponse(response);
}
}
}
}
public override void HandleRequest(Request request)
{
if (request.RequestFrom.AccessLevel >= AccessLevel.Public)
{
Match expressionMatch = _weatherRegex.Match(request.Message);
if (expressionMatch.Success)
{
string command = expressionMatch.Groups[1].Value;
string location = expressionMatch.Groups[2].Value;
WeatherResponse weatherResponse = WeatherProvider.WeatherRequest(new WeatherRequest() {Command = command, Location = location});
foreach (var message in weatherResponse.Response)
{
Response response = request.CreateResponse(ResponseType.Public, message);
ModuleManagementContainer.HandleResponse(response);
}
}
}
}
private void SendResponse(Request request)
{
var message = string.Format("{0} (V{1}) is the ##csharp irc bot on freenode.net",
NetworkConnectionInformation.BotNickname,
Assembly.GetEntryAssembly().GetName().Version.ToString(2));
var response = request.CreateResponse(ResponseTargetType.Private, message);
ModuleManagementContainer.HandleResponse(response);
response.Message = "====================================";
ModuleManagementContainer.HandleResponse(response);
response.Message = "IRC: To get help with the bot type '~Help' in private message with the bot.";
ModuleManagementContainer.HandleResponse(response);
response.Message = "Wiki: http://wiki.freenode-csharp.net/wiki/";
ModuleManagementContainer.HandleResponse(response);
response.Message = "====================================";
ModuleManagementContainer.HandleResponse(response);
response.Message = "But there's no sense crying over every mistake. You just keep on trying till you run out of cake.";
ModuleManagementContainer.HandleResponse(response);
response.Message = "Go make some new disaster. That's what I'm counting on. You're someone else's problem. Now I only want you gone.";
ModuleManagementContainer.HandleResponse(response);
}
public override void HandleRequest(Request request)
{
string[] messageArray = request.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (request.RequestFrom.AccessLevel >= AccessLevel.Public
&& request.RequestType == RequestType.Public
&& messageArray[0].Equals("~tell", StringComparison.OrdinalIgnoreCase))
{
string newMessage = string.Empty;
for (int i = 1; i < messageArray.Length; i++)
{
if (i == 1)
{
request.Addressee = messageArray[i];
}
else if (i == 2)
{
string command;
if (!messageArray[i].StartsWith("~"))
command = "~" + messageArray[i];
else
command = messageArray[i];
newMessage += command;
newMessage += " ";
}
else if (i > 2)
{
newMessage += messageArray[i];
newMessage += " ";
}
}
request.Message = newMessage.Trim();
ModuleManagementContainer.HandleRequest(request);
}
}
public override void HandleRequest(Request request)
{
// The user has permission and is indeed requesting a shutdown.
if (request.RequestFrom.AccessLevel >= AccessLevel.Root && request.Message.StartsWith("~Channel", StringComparison.OrdinalIgnoreCase))
{
// Parse our message and split out a couple of vars... a tad bit nicer than magic numbers.
string[] splitMessage = request.Message.Split(' ');
string operationDescription = splitMessage[1];
string target = splitMessage[2];
// Do the operation if we know how, else log.
if (splitMessage.Length == 3 && _supportedOperations.ContainsKey(operationDescription))
{
var operation = _supportedOperations[operationDescription];
operation.Invoke(target);
}
else
{
Logger.InfoFormat("Caught a channel action request that we don't know how to parse from {0}: {1}", request.Nick, request.Message);
}
}
}
/// <summary>
/// A conveninence method to cut down on the repetitive chatter of sending a response through our module subsystem.
/// </summary>
///
/// <param name="message">The message to send back out.</param>
/// <param name="request">Our incoming <see cref="Request"/> object, which we use for creating our response.</param>
public void SendResponse(string message, Request request)
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Private, message));
}
/// <summary> /// Given from our contract in IModule. This class does not actually provide any implementation /// details. /// </summary> /// /// <param name="request">A message relayed to this module.</param> /// /// <remarks> /// As filtering on a per-message basis is done by any given module (in theory to allow N consumers), /// every module is sent every message, and they can either handle or disregard the message. There is /// currently no mechanism for stopping propagation of the message (IE: we've handled the message). This /// may come when we hook up AOP (then we'll expect a 1:1 between message and consumer, sans advice points). /// </remarks> public abstract void HandleRequest(Request request);
/// <summary>
/// Pretty prints all the users in our system.
/// </summary>
///
/// <param name="request">A <see cref="Request"/> object we can use for creating a response to.</param>
///
/// <remarks>
/// This may get to be incredibly spammy if you have a number of hosts.
/// </remarks>
private void ListUsers(Request request)
{
SendResponse(AuthenticationManager.GetHosts().Select(x => TranslateHostToString(x)).Implode(", "), request);
}
/// <summary>
/// Attempts to delete a given hostmask, assuming it already exists.
/// </summary>
///
/// <param name="hostmask">The hostmask to remove.</param>
/// <param name="request">Our incoming <see cref="Request"/> object, which we use for creating our response.</param>
private void DeleteUser(string hostmask, Request request)
{
if (!AuthenticationManager.KnowsHost(hostmask))
{
SendResponse(String.Format("The hostmask {0} already has no current entry.", hostmask), request);
}
else
{
AuthenticationManager.ForgetHost(hostmask);
SendResponse(String.Format("The hostmask {0} has been removed.", hostmask), request);
}
}
// TODO: Kog 1/13/2010 - The thought occurs to me that it would be really nice to have some sort of syntax allowing metadata to be added
// TODO: Kog 1/13/2010 - or tags to be added with spaces. For now, let's just go with the crude stuff here.
/// <summary>
/// Deletes a metadatum for a given "tag" on a known host.
/// </summary>
///
/// <param name="host">The literal string of a cloak to modify metadata for.</param>
/// <param name="tag">The metadatum's "tag" (think of this like a key in a key/value pair). Must have no spaces</param>
/// <param name="request">Our incoming <see cref="Request"/> object, which we use for creating our response.</param>
///
/// <remarks>
/// If the host is not found (via a literal search), or the tag does not exist on the host, the outbound request will notify the calling user.
/// </remarks>
private void DeleteMetaDatumForUser(string host, string tag, Request request)
{
var knownHost = AuthenticationManager.FindHostByCloak(host);
var response = String.Format("Tag {0} successfully removed from {1}.", tag, host);
// Make sure we have the host...
if (null != knownHost)
{
var metaDatum = knownHost.MetaData.FirstOrDefault(x => x.Tag.Equals(tag, StringComparison.OrdinalIgnoreCase));
// Make sure we have that tag
if (null != metaDatum)
{
// TODO: Kog 1/13/2010 - perhaps this should just become one operation on the auth manager. The whole known host bit needs to be refactored most likely anyway.
// Tell our persistence layer to do the needful.
knownHost.MetaData.Remove(metaDatum);
AuthenticationManager.UpdateHost(knownHost);
}
else
{
response = String.Format("Could not remove tag {0} from host {1}, no such tag known.", tag, host);
}
}
else
{
response = String.Format("Host {0} doesn't exist, can't remove tag {1}", host, tag);
}
SendResponse(response, request);
}
/// <summary>
/// Attempts to either create a new metadatum entry on a known host, or update the value of a currently existing tag.
/// </summary>
///
/// <param name="host">The literal string of a cloak to modify metadata for.</param>
/// <param name="tag">The metadatum's "tag" (think of this like a key in a key/value pair). Must have no spaces.</param>
/// <param name="value">The metadatum's "value" (think of this like a value in a key/value pair). Must have no spaces.</param>
/// <param name="request">Our incoming <see cref="Request"/> object, which we use for creating our response.</param>
///
/// <remarks>
/// If the host is not found (via a literal search) the outbound request will notify the calling user.
/// </remarks>
private void CreateOrUpdateMetaDatumForUser(string host, string tag, string value, Request request)
{
var knownHost = AuthenticationManager.FindHostByCloak(host);
var response = String.Format("Tag {0} successfully added to {1}.", tag, host);
// Make sure we have the host...
if (null != knownHost)
{
// Attempt to find or create our tag.
var metaDatum = knownHost.MetaData.FirstOrDefault(x => x.Tag.Equals(tag, StringComparison.OrdinalIgnoreCase));
if (null == metaDatum)
{
// Create our new tag and add it to our mapped collection.
metaDatum = new KnownHostMetaDatum {Host = knownHost, Tag = tag};
knownHost.MetaData.Add(metaDatum);
}
// Slap in our new value.
metaDatum.Value = value;
// Tell our persistence layer to do the needful.
AuthenticationManager.UpdateHost(knownHost);
}
else
{
response = String.Format("Host {0} doesn't exist, can't remove tag {1}", host, tag);
}
SendResponse(response, request);
}
/// <summary>
/// Attempts to add the given hostmask, if it doesn't already exist.
/// </summary>
///
/// <param name="hostmask">The hostmask to add.</param>
/// <param name="level">The level to add: either <code>ADMIN</code> or <code>PUBLIC</code>. </param>
/// <param name="request">Our incoming <see cref="Request"/> object, which we use for creating our response.</param>
///
/// <remarks>
/// At present we only add <see cref="HostMatchType.Start"/> type users, and if a proper level is not specified, it is assumed that the user wants
/// a <see cref="AccessLevel.Public"/>. There is also currently no way to add a <see cref="AccessLevel.Root"/> user, which is by design.
/// </remarks>
private void AddUser(string hostmask, string level, Request request)
{
if (AuthenticationManager.KnowsHost(hostmask))
{
SendResponse(String.Format("The hostmask {0} already has an entry.", hostmask), request);
}
else
{
var host = new KnownHost
{
AccessLevel = GetAccessLevelByName(level),
HostMask = hostmask,
HostMatchType = HostMatchType.Start,
};
AuthenticationManager.RememberHost(host);
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Private, String.Format("Learned host {0}", TranslateHostToString(host))));
}
}
/// <summary>
/// Passes our internal message format to all subscribers.
/// </summary>
///
/// <param name="request">Our message to pass.</param>
public void HandleRequestReceived(Request request)
{
try
{
if (_requestReceived != null)
{
_requestReceived(this, new RequestReceivedEventArgs(request));
}
}
catch (Exception ex)
{
_logger.WarnFormat("Caught an exception trying to HandleRequestReceived on [channel {0} nick {1} request type {2} message {3}]: {4}",
request.Channel ?? "N/A", request.RequestFrom.User.DisplayName, request.RequestType, request.Message, ex);
}
}
// TODO: Kog 11/23/2009 - Do we want to keep the broadcast nature of our commands? Should we, instead, have a 1-1 mapping established at load time
// TODO: Kog 11/23/2009 - and cached in a dictionary somewhere?
// TODO: Kog 11/23/2009 - If we need this for the tell module, can we swap to using some sort of advice? Or, can we have the tell module somehow digest
// TODO: Kog 11/23/2009 - the message, and then ask the module manager to re-handle? Or does that require mutability of the request?
/// <summary>
/// Routes an incoming message to all modules for consumption.
/// </summary>
///
/// <param name="request">The message to pass.</param>
///
/// <remarks>
/// This method may seem useless, but is currently required for our Tell module.
/// </remarks>
public void HandleRequest(Request request)
{
Modules.ForEach(module => module.HandleRequest(request));
}
protected void Reply(Request request, ResponseType responseType, string responseMessage)
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseTargetType.Public, responseType, responseMessage));
}
/// <summary>
/// Provides a utility method for responding to users, cutting down on copy/paste.
/// </summary>
///
/// <param name="request">The request that triggered the message.</param>
/// <param name="responseType">The type of response to return: whether the message is public or private.<see cref="ResponseTargetType"/></param>
/// <param name="responseMessage">The literal text of the response message.</param>
/// <param name="formatObjects">An optional set of format objects. Will be passed along to String.format.</param>
///
/// <returns></returns>
protected void Reply(Request request, ResponseTargetType responseTargetType, ResponseType responseType, string responseMessage, params object[] formatObjects)
{
ModuleManagementContainer.HandleResponse(request.CreateResponse(responseTargetType, responseType, responseMessage, formatObjects));
}