private void OnStatusReceived(object sender, MessageReceivedArgs e)
{
logger.LogDebug(
"Status-Nachricht empfangen: {content}",
e.Content);
if (sessionStartRegex.IsMatch(e.Content))
{
SessionStartedEvent?.Invoke(
sender: this,
e: null);
}
else
{
var sessionStatusText = sessionStatusRegex.IsMatch(e.Content)
? sessionStatusRegex.Match(e.Content).Groups[StatusRegexGroupName].Value
: default;
var sessionStatus = sessionStatusText.GetSessionStatusType();
if (sessionStatus == default)
{
logger.LogError(
"Unbekannte Status-Nachricht empfangen: {content}",
e.Content);
}
else
{
SendSessionStatus(sessionStatus.Value);
}
}
}
public override void Process(object sender, MessageReceivedArgs argument)
{
var request = argument.Request;
var status = _statusTableProvider.Get("ServiceRequestCommand", request.Tracker.ToString());
if (status == null)
{
var statusInfo = new StatusInfo()
{
Client = request.ClientName,
CreatedTime = DateTime.UtcNow,
Status = "Created",
TrackingGuid = request.Tracker
};
status = new StatusTableEntity(statusInfo);
}
status.Status = "Processing";
_statusTableProvider.Update(status);
Thread.Sleep(3000);
var random = new Random();
request.Sku = "CSR-" + random.Next(10000, 99999);
_serviceRequestTableProvider.Update(new ServiceRequestEntity(request));
status.Status = "Completed";
status.ProcessedTime = DateTime.UtcNow;
status.Result = request.Sku;
_statusTableProvider.Update(status);
Console.WriteLine($"Cost Rate Request Processing Complete - {request.Tracker}");
}
private async Task OnMessageReceived(SocketMessage arg)
{
if (!(arg is SocketUserMessage))
{
return;
}
MessageContext context = new MessageContext(arg as SocketUserMessage);
string prefix = TamaChan.Instance.botSettings.commandPrefix;
bool isCommand = !arg.Author.IsBot && arg.Content.StartsWith(prefix);
MessageReceivedArgs messageReceivedArgs = new MessageReceivedArgs(arg as SocketUserMessage, isCommand);
await messageReceivedEvent?.Invoke(messageReceivedArgs);
if (messageReceivedArgs.isCanceled)
{
return;
}
if (MenuHandler.IsAwaitingResponseFrom(arg.Author.Id, arg.Channel.Id))
{
object response = MenuHandler.HandleResponse(arg.Author.Id, arg.Channel.Id, context);
if (response != null)
{
await ResponseHandler.Instance.Respond(response, arg.Channel);
}
}
if (isCommand)
{
await commandInvoker.InvokeCommand(arg.Content.Split(' ')[0].Remove(0, prefix.Length), context, arg as SocketUserMessage);
}
}
public override void Process(object sender, MessageReceivedArgs argument)
{
var request = argument.Request;
Console.WriteLine($"Part Number Request Processing - {request.Tracker}");
try
{
var status = _statusTableProvider.Get("ServiceRequestCommand", request.Tracker.ToString());
if (status == null)
{
var statusInfo = new StatusInfo()
{
Client = request.ClientName,
CreatedTime = DateTime.UtcNow,
Status = "Created",
TrackingGuid = request.Tracker
};
status = new StatusTableEntity(statusInfo);
}
status.Status = "Processing";
_statusTableProvider.Update(status);
Thread.Sleep(3000);
var random = new Random();
var errorNumber = random.Next(0, 3);
if (errorNumber == 2)
{
throw new Exception($"Failed to create Part Number for {request.Tracker}");
}
request.Sku = "PNR-" + random.Next(10000, 99999);
_serviceRequestTableProvider.Update(new ServiceRequestEntity(request));
status.Status = "Completed";
status.ProcessedTime = DateTime.UtcNow;
status.Result = request.Sku;
_statusTableProvider.Update(status);
}
catch (Exception exception)
{
var status = _statusTableProvider.Get("ServiceRequestCommand", request.Tracker.ToString());
if (status == null)
{
var statusInfo = new StatusInfo()
{
Client = request.ClientName,
CreatedTime = DateTime.UtcNow,
Status = "Created",
TrackingGuid = request.Tracker
};
status = new StatusTableEntity(statusInfo);
}
status.Status = "Failed";
_statusTableProvider.Update(status);
Console.WriteLine($"Part Number Request Processing has failed- {request.Tracker}");
throw;
}
}
void OnMessageReceived(MessageReceivedArgs oArgs)
{
if (MessageReceived != null)
{
MessageReceived(this, oArgs);
}
}
public static void MessageReceived(object sender, MessageReceivedArgs args)
{
if (args.Message.IndexOf($"{args.Prefix}help", StringComparison.InvariantCultureIgnoreCase) == 0)
{
HelpMethod(sender, args);
}
}
private static void Server_MessageReceived(object sender, MessageReceivedArgs e)
{
var receivedData = Encoding.ASCII.GetString(e.Data, 0, e.Data.Length);
var msg = SyslogMessage.Parse(e.IPEndPoint, receivedData);
Console.WriteLine(msg.ToString());
}
public void OnMessageReceived(object sender, MessageReceivedArgs args)
{
Message message = (Message)args.Message;
message.Sender = args.Sender;
MessageProcessor.ProcessMessage(message);
}
void HandleMessageReceived(object sender, MessageReceivedArgs e)
{
switch ((Command)e.Command)
{
case Command.Import:
HandleImport(e.MessageData.Text);
e.RetVal = Response.Ok;
break;
case Command.Organize:
HandleOrganize();
e.RetVal = Response.Ok;
break;
case Command.Shutdown:
HandleShutdown();
e.RetVal = Response.Ok;
break;
case Command.Slideshow:
HandleSlideshow(e.MessageData.Text);
e.RetVal = Response.Ok;
break;
case Command.View:
HandleView(e.MessageData.Uris);
e.RetVal = Response.Ok;
break;
case Command.Invalid:
default:
Log.Debug("Wrong command received");
break;
}
}
private void SocketMessageReceived(object sender,
MessageReceivedArgs e)
{
var array = JsonConvert.DeserializeObject <JArray>(e.Message);
dynamic messageObj = array[0];
var newAdvice = ParseAdvice(messageObj);
if (newAdvice != null)
{
_advice = newAdvice;
SetRetry(_advice,
_connection);
}
if (HandleSynchronousReply(messageObj,
e))
{
return;
}
if (HandleConnectResponse(messageObj))
{
return;
}
var message = Converter.Deserialize <DataMessage>(e.Message);
var channel = message.Channel;
var messageData = message.Data.ToString(CultureInfo.InvariantCulture);
_logger.Debug("Message data received for channel '{0}' is '{1}",
channel,
messageData);
_subscribedChannels[channel].ForEach(handler => handler(messageData));
}
private void Server_TcpMessageReceived(IArdNetSystem Sender, MessageReceivedArgs e)
{
Console.WriteLine("New TCP Message");
Console.WriteLine(" Connection Time: " + ((dynamic)e.ConnectedSystem.UserState).Time);
Console.WriteLine(" IP Address: " + e.Endpoint);
Console.WriteLine(" Message: " + (e.Message ?? "[NULL]"));
}
protected override void RunLoop()
{
using (var redisClient = clientsManager.GetReadOnlyClient())
{
using (var subscription = redisClient.CreateSubscription())
{
subscription.OnUnSubscribe = channel => Log.Debug("OnUnSubscribe: " + channel);
subscription.OnMessage = (channel, msg) =>
{
if (msg == WorkerStatus.StopCommand)
{
Log.Debug("Stop Command Issued");
if (Interlocked.CompareExchange(ref status, WorkerStatus.Stopped, WorkerStatus.Started) != WorkerStatus.Started)
{
Interlocked.CompareExchange(ref status, WorkerStatus.Stopped, WorkerStatus.Stopping);
}
Log.Debug("UnSubscribe From All Channels...");
subscription.UnSubscribeFromAllChannels(); //Un block thread.
return;
}
this.IncrementMessageCount(1);
var messageReceivedArgs = new MessageReceivedArgs {
QueueName = msg
};
this.MqServer.NotifyMessageReceived(messageReceivedArgs);
};
subscription.SubscribeToChannels(QueueNames.TopicIn); //blocks thread
}
}
}
protected void OnMessageReceived(object o, MessageReceivedArgs args)
{
Hashtable obj = JSON.Decode(System.Text.Encoding.UTF8.GetBytes(args.Json));
if (obj["type"].ToString() == "message")
{
string severity = obj["severity"].ToString();
string message = obj["message"].ToString();
if (severity == "info")
{
LogInfo(message);
}
else if (severity == "warning")
{
LogWarning(message);
}
else if (severity == "error")
{
LogError(message);
}
else if (severity == "debug")
{
LogDebug(message);
}
}
}
private static void HelpMethod(object sender, MessageReceivedArgs args)
{
var content = new StringBuilder();
content.AppendLine("**SpyderWeb**");
content.AppendLine("A utility bot for Discord.Net\n");
content.AppendLine("```");
// foreach (var module in _commandService.Modules)
// {
// if (_tagService.Module != null && module == _tagService.Module) continue;
// if (module.Commands.Count == 0) continue;
// content.AppendLine(module.Name);
// foreach (var command in module.Commands)
// content.AppendLine(command.Name.PadRight(27) + command.Summary);
// content.AppendLine();
// }
content.AppendLine("```");
content.AppendLine("Commands suffixed with a '*' are restricted to elevated actors");
SendMessage(sender, content.ToString());
}
private void MessageReceived(object sender, MessageReceivedArgs e)
{
// Split content up into identifier and actual content
var receivedMessage = MakeReceivedMessage(e.ReceivedMessage);
if (receivedMessage == null)
{
return;
}
try
{
if (_callbacks.ContainsKey(receivedMessage.Identifier))
{
var callback = _callbacks[receivedMessage.Identifier];
callback?.Invoke(receivedMessage);
return;
}
// If no callbacks with matching identifiers are found, send as a generic callback
_genericCallback?.Invoke(receivedMessage);
}
catch (Exception)
{
}
}
private void MessageBusOnMessageReceived(object sender, MessageReceivedArgs e)
{
if (e.Message.Topic == myTopic && e.Message.Payload == "resend_all")
{
myResendAll = true;
TimerOnElapsed(null, null);
}
}
private static void Instance_MessageReceived(Codey sender, MessageReceivedArgs args)
{
Console.WriteLine("msg:" + args.Message.Name);
if (args.Message.Name.Equals("Start"))
{
Codey.Instance.SendMessage("start");
}
}
private async Task ProcessMessageAsync(SB.Message message, CancellationToken token)
{
await Task.Run(() =>
{
var messageReceivedArgs = new MessageReceivedArgs(message);
MessageReceived(this, messageReceivedArgs);
});
}
private void RaiseMessageReceivedEvent(Client sender, string message)
{
MessageReceivedArgs e = new MessageReceivedArgs(sender, message);
if (MessageReceived != null)
{
MessageReceived(this, e);
}
}
public void MessagedReceived(object sender, MessageReceivedArgs messageReceivedArgs)
{
using (var scope = Services.CreateScope())
{
var scopedProcessingService =
scope.ServiceProvider
.GetRequiredService <IMiddlewaresMessageHandlerService>();
scopedProcessingService.MessageReceivedFromMiddlewares(this, messageReceivedArgs);
}
}
public void OnMessageReceived(object sender, MessageReceivedArgs args)
{
var message = (Message)args.Message;
try
{
message.Sender = args.Sender;
Processor.ProcessMessage(message);
}
catch (NullReferenceException) {}
}
private void MessageBusOnMessageReceived(object sender, MessageReceivedArgs e)
{
if (e.Message.Topic != myTopic)
{
return;
}
if (e.Message.Payload == "resend_all")
{
TimerElapsed(null, null, true);
}
}
private void ReceivedCommandAnswer(object sender, MessageReceivedArgs messageReceivedArgs)
{
_answeredSemaphore.WaitOne();
if (CommunicationStatus != CommunicationStatus.Busy || CommandStatus != CommandStatus.NoCommissioned /*TODO*/)
{
return;
}
Answered = true;
SendCommandAnswer(messageReceivedArgs.MessageReceived.Payload);
CommunicationStatus = CommunicationStatus.Success;
_answeredSemaphore.Release();
}
private static void SmtpServer_MessageReceived(object sender, MessageReceivedArgs e)
{
if (ReceivedEmails.Count == MaximumLimit)
{
ReceivedEmails.RemoveAt(ReceivedEmails.Count - 1);
}
var newEmailId = (ReceivedEmails.Count == 0) ? 1 : ReceivedEmails[0].Id + 1;
ReceivedEmails.Insert(0, new Email(e.Message, newEmailId));
SmtpServer.ClearReceivedEmail();
}
private bool HandleSynchronousReply(dynamic message,
MessageReceivedArgs e)
{
int messageId = message.id;
bool isControlMessage = message.data == null;
if (!isControlMessage || !_synchronousMessageEvents.ContainsKey(messageId))
{
return(false);
}
_synchronousMessageEvents[messageId].SetResult(e);
return(true);
}
private AsyncReplyHandling <char> Setup()
{
// Handle adds the received message to the queue.
var eh = new EventHandler <MessageReceivedArgs <IEnumerable <char> > >((obj, args) => { });
// Sending a message Invokes the OnReceive handle directly.
void smd(IEnumerable <char> arg)
{
var args = new MessageReceivedArgs <IEnumerable <char> >(arg);
eh.DynamicInvoke(this, args);
}
return(new AsyncReplyHandling <char>(smd, ref eh, '?', '*'));
}
private void ReceiveMessage(object sender, MessageReceivedArgs e)
{
var command = e.ReceivedMessage.Message;
if (command == null || command.Length == 0)
{
throw new InvalidOperationException("Dache.CacheHost.Communication.CacheHostServer.ReceiveMessage - command variable is null or empty, indicating an empty or invalid message");
}
// Get the command string skipping our control byte
var commandString = DacheProtocolHelper.CommunicationEncoding.GetString(command);
// Right now this is only used for invalidating cache keys, so there will never be a reply
ProcessCommand(commandString);
}
private void ReceiveMessage(object sender, MessageReceivedArgs e)
{
var command = e.ReceivedMessage.Message;
if (command == null || command.Length == 0)
{
return;
}
// Get the command string
int position = 0;
var commandString = DacheProtocolHelper.CommunicationEncoding.GetString(DacheProtocolHelper.Extract(command, ref position));
// Right now this is only used for invalidating cache keys, so there will never be a reply
ProcessCommand(commandString, command, position);
}
/// <summary>
/// Handle to provide to the Message Received Event handle.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void OnReceived(object sender, MessageReceivedArgs <IEnumerable <TContent> > args)
{
IList <TaskCompletionSource <IEnumerable <TContent> > > toCall;
// Collect all sources for the received message.
pattern_lock.EnterReadLock();
try
{
toCall = Patterns.Collect(args.Received);
}
finally { pattern_lock.ExitReadLock(); }
foreach (TaskCompletionSource <IEnumerable <TContent> > t in toCall)
{
t.TrySetResult(args.Received);
}
}
private void Server_MessageReceived(Server sender, MessageReceivedArgs e)
{
// Console.WriteLine(e.IpAddress);
// Console.WriteLine(e.Message);
HttpRequestObject req = new HttpRequestObject(e.Message);
HttpResponseObject res = new HttpResponseObject("1.1");
Console.WriteLine($"{e.IpAddress} =-= {req.Path}");
// Console.WriteLine($"");
string localPath = targetPath + req.Path;
if (File.Exists(localPath))
{
res.ResponseCode = 200;
var ext = Path.GetExtension(localPath);
res.StoreHeader("Content-Type", Extension.ToContentType[ext.Trim('.')] + ";");
res.StoreHeader("Connection", "keep-alive");
using (FileStream fs = new FileStream(targetPath + req.Path, FileMode.Open, FileAccess.Read)) {
byte[] bs = new byte[fs.Length];
fs.Read(bs, 0, bs.Length);
res.Ingredients = bs;
}
}
else
{
res.ResponseCode = 404;
}
Console.WriteLine($"{req.Path} : {res.ResponseCode}");
sender.Send(e.IpAddress, res.ToByteArrayAll());
// sender.Send(e.IpAddress, "HTTP/1.1 200 OK\r\n");
// sender.Send(e.IpAddress, "Content-Type: text/plain; charset=UTF-8\r\n");
// sender.Send(e.IpAddress, "Connection: close\r\n");
// sender.Send(e.IpAddress, "\r\n");
// sender.Send(e.IpAddress, "Copyright (C) Redkun. 2020\r\n");
// sender.Send(e.IpAddress, $"now is {DateTime.Now}\r\n");
//
// sender.Disconnect(e.IpAddress);
}
private void OnMessageReceived(object sender, MessageReceivedArgs args)
{
_timeoutCancelationToken.Cancel();
_completion.TrySetResult(args.Message.Data);
}
void OnMessageReceived(MessageReceivedArgs oArgs)
{
if(MessageReceived != null)
MessageReceived(this, oArgs);
}
