public override void Execute(IExecutionEnvironment environment, MessageReceivedEvent e, string commandArgs)
{
if (e.Instigator.VoiceChannel is null)
{
e.Channel.SendMessageAsync("Вам требуется зайти в какой-либо голосовой канал").RunSync();
return;
}
IMusicSearchService musicSearchService = environment.GetService <IMusicSearchService>();
IMusicPlayer musicPlayer = environment.GetService <IMusicPlayer>();
string[] results = musicSearchService.GetOrCreateMusicSources(commandArgs).ToArray();
if (results.Length == 0)
{
e.Channel.SendMessageAsync("Не найдено ни одного результата по данному запросу").RunSync();
return;
}
string source = results[Random.Next(results.Length)];
musicPlayer.Play(e.Instigator.VoiceChannel, e.Channel, e.GuildId, source);
EmbedBuilder builder = new EmbedBuilder();
builder.AddField(Path.GetFileNameWithoutExtension(source), $"Now playing (selected from {results.Length} sources)");
builder.WithColor(Color.Green);
e.Channel.SendMessageAsync(null, false, builder.Build()).RunSync();
}
public override void Execute(IExecutionEnvironment environment, MessageReceivedEvent e, string commandArgs)
{
StringBuilder message = new StringBuilder("Упомянутые каналы\n");
foreach (var channel in e.Message.MentionedChannels)
{
message
.Append("Название: " + channel.Name + "\n")
.Append("ID: " + channel.Id + "\n")
.Append("Создан: " + channel.CreatedAt.ToString() + "\n");
}
e.Channel.SendMessageAsync(message.ToString()).GetAwaiter().GetResult();
message = new StringBuilder("Упомянутые роли\n");
foreach (var role in e.Message.MentionedRoles)
{
message
.Append("Название: " + role.Name + "\n")
.Append("ID: " + role.Id + "\n")
.Append("Возможность пинговать: " + role.IsMentionable + "\n")
.Append("Цвет: " + role.Color.RawValue + "\n");
}
e.Channel.SendMessageAsync(message.ToString()).GetAwaiter().GetResult();
message = new StringBuilder("Упомянутые пользователи\n");
foreach (var user in e.Message.MentionedUsers)
{
message
.Append("Имя: " + user.Username + "\n")
.Append("ID: " + user.Id + "\n")
.Append("Статус: " + user.Status);
}
e.Channel.SendMessageAsync(message.ToString()).GetAwaiter().GetResult();
}
private void send_notices(IList <SidePOPMailMessage> messages)
{
if (messages == null || messages.Count == 0)
{
return;
}
Log.bound_to(this).log_a_debug_event_containing("{0} is sending notice of {1} messages.", ApplicationParameters.name, messages.Count);
MessageListEventArgs messages_event_args = new MessageListEventArgs(messages);
MessagesReceivedEvent messages_received = MessagesReceived;
if (messages_received != null)
{
messages_received(this, messages_event_args);
}
foreach (SidePOPMailMessage message in messages)
{
Log.bound_to(this).log_a_debug_event_containing("{0} is sending notice of message id \"{1}\".", ApplicationParameters.name, message.MessageId);
MessageEventArgs message_event_args = new MessageEventArgs(message);
MessageReceivedEvent message_received = MessageReceived;
if (message_received != null)
{
message_received(this, message_event_args);
}
}
}
private void WaitForData()
{
while (true)
{
try
{
var data = new byte[GlobalConfig.Size];
var builder = new StringBuilder();
UserMessage receivedObject;
do
{
var bytes = Stream.Read(data, 0, data.Length);
receivedObject = JsonSerializer.Deserialize <UserMessage>(Encoding.UTF8.GetString(data, 0, bytes));
builder.Append(receivedObject);
}while (Stream.DataAvailable);
var message = builder.ToString();
Console.WriteLine(message);
MessageReceivedEvent?.Invoke(receivedObject, this);
}
catch (JsonException ex)
{
Console.WriteLine(ex.Message);
}
catch
{
Console.WriteLine($"Подключение {Id} прервано!");
Disconnect();
break;
}
}
}
private void SafeInvokeMessageRecevied(MessageReceivedEventArgs eventArgs)
{
if (this.RemoteMessage == null)
{
return; //No Listeners
}
MessageReceivedEvent listener = null;
Delegate[] dels = this.RemoteMessage.GetInvocationList();
foreach (Delegate del in dels)
{
try
{
listener = (MessageReceivedEvent)del;
listener.Invoke(eventArgs);
}
catch (Exception)
{
//Could not reach the destination, so remove it
//from the list
this.RemoteMessage -= listener;
}
}
}
public TCPBase(int id, TcpClient client, MessageReceivedEvent messageReceiver, DiconnectedEvent disconnectHandler)
{
this.id = id;
this.client = client;
this.MessagesHandler = messageReceiver;
this.DiconnectionHandler = disconnectHandler;
}
private void GreetIfNecessary(MessageReceivedEvent @event)
{
ChannelUser user = @event.User;
if (presenceStore.IsGreetingNecessary(user))
{
var now = DateTimeOffset.Now;
string?phrase;
if (now.Hour > 0 && now.Hour < 11)
{
phrase = "Guten Morgen";
}
else if (now.Hour >= 11 && now.Hour < 18)
{
phrase = "Hallo";
}
else
{
phrase = "Guten Abend";
}
bus.Publish(new TextToSpeechEvent(user, $"{phrase} {user.Username}"));
presenceStore.RecordPresence(user);
}
}
private void CheerForBirthday(MessageReceivedEvent message)
{
var birthdayConfiguration = configurationManager.LoadConfiguration <BirthdaysConfiguration>();
DateTime now = DateTime.Now;
if (birthdayConfiguration.ContainsBirthdayForDate(now))
{
var changed = false;
var birthdays = birthdayConfiguration.GetBirthdays(now);
foreach (var birthday in birthdays)
{
if (birthday.UserId == message.User.UserId && !birthday.Gratulated.Contains(now.Year))
{
changed = true;
birthday.Gratulated.Add(now.Year);
bus.Publish(new TextToSpeechEvent(message.User, $"Alles Gute zu deinem Geburtstag {message.User.Username}! Genieße deinen Geburstag in unserem Stream. Mach es dir gemütlich."));
break;
}
}
if (changed)
{
birthdayConfiguration.MarkChanged();
}
}
}
private void CheckForSoundCommands(MessageReceivedEvent message)
{
if (!message.HasEmotesInMessage)
{
return;
}
var soundConfiguration = configurationManager.LoadConfiguration <CommandConfiguration>();
foreach (var emoteInMessage in message.EmotesInMessage)
{
if (!soundConfiguration.TryGetDefinition(emoteInMessage.Name, out CommandDefinition commandDefinition))
{
continue;
}
var command = commandDefinition.CreateCommand();
if (!command.ShouldExecute)
{
continue;
}
bus.Publish(new PlaySoundEvent(command.Filename, command.Volume));
command.MarkAsExecuted();
}
}
async Task OnMessageReceived(MessageReceivedEvent message)
{
if (message.Key == "NewWord")
{
string word = message.AsJObject().Value <string>("Word");
}
}
private async void PacketReceivedEventHandler(object sender, PacketReceivedEventArgs e)
{
if (!Message.IsMessageContentType(e.Packet.ContentType))
{
await ErrorAsync("Packet content is not a message!").ConfigureAwait(false);
return;
}
// TODO: exceptions here?
Logger.Debug("Attempting to parse a message...");
Message message = await Message.DeSerializeAsync(e.Packet.ContentType, e.Packet.Encoding, e.Packet.Content, 0, e.Packet.ContentLength, MessageFactory).ConfigureAwait(false);
if (null == message)
{
await ErrorAsync("Failed to parse a message!").ConfigureAwait(false);
return;
}
Logger.Debug($"{message.Type} message parsed!");
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs
{
Message = message
}
);
}
public MessageReceivedAt2Event MessageReceivedAt2EventFromHead(MessageReceivedEvent ho)
{
var o = new MessageReceivedAt2Event();
o.Title = "";
o.Lines = ho.Content.UnifyNewLineToLf().Split('\n').ToList();
return(o);
}
public ClientPeerConnection(IPEndPoint superPeerEndPoint, MessageReceivedEvent onMessageReceivedEvent,
ConnectionClosedEvent onConnectionClosedEvent)
: base(new JsonSerializer())
{
MessageReceivedEvent = onMessageReceivedEvent;
ConnectionClosedEvent = onConnectionClosedEvent;
Peer = new ClientPeer(superPeerEndPoint);
}
private void ProcessChatMessage(MessageReceivedEvent message)
{
GreetIfNecessary(message);
SayByeIfNecessary(message);
CheckForSoundCommands(message);
SpeakIfNecessary(message);
CheerForBirthday(message);
}
private async Task ReadAsync(Package package)
{
// побуферно читаем сообщения, что позволяет не ограничиваться его размером
var readBytes = await _pipeServer.ReadAsync(package.Buffer, 0, package.Buffer.Length);
if (readBytes > 0)
{
byte[] result;
if (_pipeServer.IsMessageComplete)
{
result = new byte[readBytes];
Array.Copy(package.Buffer, 0, result, 0, readBytes);
}
else
{
result = package.Buffer;
}
package.Result.AddRange(result);
// если не дочитали...
if (!_pipeServer.IsMessageComplete)
{
// ...то читаем следующий буфер
await ReadAsync(package);
}
else
{
using (var stream = new MemoryStream(package.Result.ToArray()))
{
var message = Serializer.Deserialize <T>(stream);
MessageReceivedEvent?.Invoke(this,
new MessageReceivedEventArgs <T>
{
ClientId = responceClientId,
Message = message
});
}
await ReadAsync(new Package());
}
}
// Если прочитано 0 байт, то клиент вероятно отключился
else
{
if (!_isStopping)
{
Stop();
ClientDisconnectedEvent?.Invoke(
this,
new ClientDisconnectedEventArgs {
ClientId = responceClientId
});
}
}
}
/// <summary>
/// Message event as decoded string
/// </summary>
/// <param name="message">Decoded message</param>
public void MessageReceived(string message)
{
//Debug.Log ("UDP:Received:"+message);
//Message Received event for listeners
if (MessageReceivedEvent != null)
{
MessageReceivedEvent.Invoke(message);
}
}
private void TryRaiseMessageEvent(string eventName, JObject jsonObjectEvent)
{
var json = jsonObjectEvent.ToString();
var eventInfo = _jsonObjectConverter.Deserialize <AccountActivityMessageCreatedEventDTO>(json);
eventInfo.MessageEvents.ForEach(messageEventDTO =>
{
App app = null;
if (messageEventDTO.MessageCreate.SourceAppId != null)
{
eventInfo.Apps?.TryGetValue(messageEventDTO.MessageCreate.SourceAppId.ToString(), out app);
}
eventInfo.UsersById.TryGetValue(messageEventDTO.MessageCreate.SenderId.ToString(), out var senderDTO);
eventInfo.UsersById.TryGetValue(messageEventDTO.MessageCreate.Target.RecipientId.ToString(), out var recipientDTO);
var sender = _factories.CreateUser(senderDTO);
var recipient = _factories.CreateUser(recipientDTO);
var message = _factories.CreateMessage(messageEventDTO, app);
var accountActivityEvent = new AccountActivityEvent <IMessage>(message)
{
AccountUserId = AccountUserId,
EventDate = message.CreatedAt,
Json = json
};
if (message.SenderId == AccountUserId)
{
var eventArgs = new MessageSentEvent(accountActivityEvent, message, sender, recipient, app);
this.Raise(MessageSent, eventArgs);
if (eventArgs.InResultOf == MessageSentInResultOf.Unknown)
{
this.Raise(EventKnownButNotFullySupportedReceived, new EventKnownButNotSupported(json, eventArgs));
}
}
else if (message.RecipientId == AccountUserId)
{
var eventArgs = new MessageReceivedEvent(accountActivityEvent, message, sender, recipient, app);
this.Raise(MessageReceived, eventArgs);
if (eventArgs.InResultOf == MessageReceivedInResultOf.Unknown)
{
this.Raise(EventKnownButNotFullySupportedReceived, new EventKnownButNotSupported(json, eventArgs));
}
}
else
{
this.Raise(UnsupportedEventReceived, new UnsupportedMessageReceivedEvent(jsonObjectEvent.ToString()));
}
});
}
private async Task ReceiveMessage(MqttApplicationMessageReceivedEventArgs e)
{
Debug.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
Debug.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
Debug.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
Debug.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
Debug.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
Debug.WriteLine("");
MessageReceivedEvent?.Invoke(e);
}
public override void Execute(IExecutionEnvironment environment, MessageReceivedEvent e, string commandArgs)
{
EmbedBuilder builder = new EmbedBuilder();
builder.AddField("Field name", "__value__");
builder.AddField("Field 2 name", "__val2");
builder.AddField("inline field", "inval", true);
builder.WithColor(Color.Green);
e.Channel.SendMessageAsync(null, false, builder.Build());
}
protected virtual void OnMessage(RemoteServer server, MessageEventArgs args)
{
MessageEvent?.Invoke(server, args);
if (args.Sent)
{
MessageSentEvent?.Invoke(server, args);
}
else
{
MessageReceivedEvent?.Invoke(server, args);
}
}
public async ValueTask OnMessageCreate(IDiscordMessage message)
{
var @event = new MessageReceivedEvent(message);
await _eventManager.CallAsync(@event);
if (@event.IsCancelled || string.IsNullOrEmpty(message.Content))
{
return;
}
var scope = _provider.CreateScope();
var features = new FeatureCollection();
var responseFeature = new MessageResponseFeature();
features.Set <IServiceProvidersFeature>(new ServiceProvidersFeature(scope.ServiceProvider));
features.Set <IUserFeature>(new UserFeature(message.Author));
features.Set <IMessageResponseFeature>(responseFeature);
features.Set <IMessageRequestFeature>(new MessageRequestFeature
{
GuildId = message.GuildId,
ChannelId = message.ChannelId,
MessageId = message.Id,
Message = message.Content
});
var context = _messageContextFactory.Create(features);
try
{
CultureInfo.CurrentCulture = _localizer.DefaultCulture;
_contextAccessor.Context = context;
await _application(context);
await _contextDispatcher.DispatchAsync(context);
}
catch (Exception e)
{
_logger.LogError(e, "An exception occured while processing the message '{Content}' from {User}.", message.Content, message.Author.Username);
if (_debugOptions.ThrowOnMessageException)
{
throw;
}
}
finally
{
scope.Dispose();
_messageContextFactory.Dispose(context);
}
}
public override void Execute(IExecutionEnvironment environment, MessageReceivedEvent e, string commandArgs)
{
IMusicSearchService musicSearchService = environment.GetService <IMusicSearchService>();
IMusicPlayer musicPlayer = environment.GetService <IMusicPlayer>();
IEnumerable <string> files = musicSearchService.GetOrCreateMusicSources(commandArgs);
if (files.Count() == 0)
{
e.Channel.SendMessageAsync("Не найдено ни одного результата по данному запросу").RunSync();
return;
}
EmbedBuilder builder = null;
if (files.Count() > 1)
{
builder = new EmbedBuilder();
builder.WithTitle("Несколько результатов найдено");
builder.WithDescription("Попробуйте указать более точное название");
int counter = 1;
int advancedResults = 0;
foreach (var file in files)
{
if (counter < EmbedBuilder.MaxFieldCount - 1)
{
builder.AddField(counter.ToString() + ".", System.IO.Path.GetFileNameWithoutExtension(file));
}
else
{
++advancedResults;
}
++counter;
}
if (advancedResults > 0)
{
builder.AddField($"Ещё результаты ({advancedResults})", "...");
}
builder.WithColor(Color.LightGrey);
e.Channel.SendMessageAsync(null, false, builder.Build()).RunSync();
return;
}
if (e.Instigator.VoiceChannel is null)
{
e.Channel.SendMessageAsync("Вам требуется зайти в какой-либо голосовой канал").RunSync();
return;
}
string source = musicSearchService.GetOrCreateMusicSources(commandArgs).First();
musicPlayer.Play(e.Instigator.VoiceChannel, e.Channel, e.GuildId, source);
builder = new EmbedBuilder();
builder.AddField(Path.GetFileNameWithoutExtension(source), "Now playing");
builder.WithColor(Color.Green);
e.Channel.SendMessageAsync(null, false, builder.Build()).RunSync();
}
private void OnMessageReceived(object o, BasicDeliverEventArgs e)
{
Console.WriteLine("Message received");
if (!string.Equals(API.DemoMessage.Descriptor.Name, e.BasicProperties.Type,
StringComparison.OrdinalIgnoreCase))
{
return;
}
var message = API.DemoMessage.Parser.ParseFrom(e.Body.ToArray());
MessageReceivedEvent?.Invoke(this, new MessageReceivedEventArgs(message));
}
/// <summary>
/// Waits for a message to be received
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <returns>The message type</returns>
/// <param name="timeout">The timeout in milliseconds</param>
public T WaitForServerEvent <T>(int timeout) where T : IServerEvent
{
MessageReceivedEvent messageEvent = new MessageReceivedEvent();
m_MessageAwaiters.Add(typeof(T), messageEvent);
messageEvent.WaitForMessage(timeout);
T eventResult = (T)messageEvent.Message;
messageEvent.Dispose();
m_MessageAwaiters.Remove(typeof(T));
return((T)messageEvent.Message);
}
public void TestJournalMessageReceived1()
{
string line = @"{ ""timestamp"":""2016-10-07T03:02:44Z"", ""event"":""ReceiveText"", ""From"":""$ShipName_Police_Federation;"", ""From_Localised"":""Federal Security Service"", ""Message"":""$Police_StartPatrol03;"", ""Message_Localised"":""Receiving five by five, I'm in the air now, joining patrol."", ""Channel"":""npc"" }";
List <Event> events = JournalMonitor.ParseJournalEntry(line);
Assert.IsTrue(events.Count == 1);
MessageReceivedEvent theEvent = (MessageReceivedEvent)events[0];
Assert.IsFalse(theEvent.player);
Assert.AreEqual("Police", theEvent.source);
Assert.AreEqual("Federal Security Service", theEvent.from);
}
private void HandleMessage(string msg)
{
MediaResult result = MediaResult.FromJson(msg);
if (result.isOk())
{
MessageReceivedEvent?.Invoke(result);
}
else
{
Debug.Print("error: " + result.ToString());
}
Debug.Print(result.ToString());
}
public void TestJournalPlayerLocalChat()
{
string line = @"{ ""timestamp"":""2017 - 10 - 12T20: 39:25Z"", ""event"":""ReceiveText"", ""From"":""Rebecca Lansing"", ""Message"":""Hi there"", ""Channel"":""local"" }";
List <Event> events = JournalMonitor.ParseJournalEntry(line);
Assert.IsTrue(events.Count == 1);
MessageReceivedEvent event1 = (MessageReceivedEvent)events[0];
Assert.IsTrue(event1.player);
Assert.AreEqual("Commander", event1.source);
Assert.AreEqual("Rebecca Lansing", event1.from);
Assert.AreEqual("Hi there", event1.message);
}
public void TestJournalPlayerWingChat()
{
string line = @"{ ""timestamp"":""2017-10-12T21:11:10Z"", ""event"":""ReceiveText"", ""From"":""SlowIce"", ""Message"":""hello"", ""Channel"":""wing"" }";
List <Event> events = JournalMonitor.ParseJournalEntry(line);
Assert.IsTrue(events.Count == 1);
MessageReceivedEvent event1 = (MessageReceivedEvent)events[0];
Assert.IsTrue(event1.player);
Assert.AreEqual("Wing mate", event1.source);
Assert.AreEqual("SlowIce", event1.from);
Assert.AreEqual("hello", event1.message);
}
private void Run()
{
while (true)
{
Message m = _messageQueue.Receive();
Stock s = m.Body as Stock;
if (s != null)
{
if (s.Index.Equals(_indexFilter))
{
MessageReceivedEvent.Invoke(this, new StockMessageEventArgs(s));
}
}
}
}
public void TestJournalPlayerDirectMessage()
{
string line = "{ \"timestamp\":\"2017-10-12T19:58:46Z\", \"event\":\"ReceiveText\", \"From\":\"SlowIce\", \"Message\":\"good luck\", \"Channel\":\"player\" }";
List <Event> events = JournalMonitor.ParseJournalEntry(line);
Assert.IsTrue(events.Count == 1);
MessageReceivedEvent event1 = (MessageReceivedEvent)events[0];
Assert.IsTrue(event1.player);
Assert.AreEqual("Commander", event1.source);
Assert.AreEqual("SlowIce", event1.from);
Assert.AreEqual("good luck", event1.message);
}
private void PubSubClient_OnMessageDeleted(object sender, MessageDeletedEvent e)
{
var messageReceivedEvent = new MessageReceivedEvent()
{
AutoModded = false,
Channel = e.Channel,
Deleted = true,
DisplayName = e.Username,
Message = e.Message,
DeletedBy = e.DeletedBy,
TwitchMessageId = e.TwitchMessageId
};
OnMessageReceived?.Invoke(messageReceivedEvent);
}
