public void SendChatToTeam(ServerPlayer from, TeamColors to, string chat, bool action)
{
if (chat == string.Empty)
{
return;
}
ChatMessageEventArgs args = new ChatMessageEventArgs();
args.From = from;
args.To = null;
args.ToTeam = to;
args.MessageText = chat;
args.Action = action;
args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerTeamMessage : ChatMessageEventArgs.ChatMessageTypes.TeamMessage;
if (args.ToTeam == TeamColors.NoTeam)
{
return;
}
MsgMessage msg = new MsgMessage();
msg.MessageText = chat;
msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID;
msg.To = PlayerConstants.GetTeamPlayerID(to);
msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage;
Players.SendToTeam(msg, to, false);
MessageSent?.Invoke(this, args);
}
public void SendChatToGroup(ServerPlayer from, GroupInfo to, string chat, bool action)
{
if (chat == string.Empty)
{
return;
}
ChatMessageEventArgs args = new ChatMessageEventArgs();
args.From = from;
args.To = null;
args.ToTeam = TeamColors.NoTeam;
args.ToGroup = to;
args.MessageText = chat;
args.Action = action;
args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerGroupMessage : ChatMessageEventArgs.ChatMessageTypes.GroupMessage;
if (args.ToTeam == TeamColors.NoTeam)
{
return;
}
MsgMessage msg = new MsgMessage();
msg.MessageText = chat;
msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID;
msg.To = to.BroadcastID;
msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage;
to.SentTo(msg, false);
MessageSent?.Invoke(this, args);
}
public void SendChatToAll(ServerPlayer from, string chat, bool action)
{
if (chat == string.Empty)
{
return;
}
ChatMessageEventArgs args = new ChatMessageEventArgs();
args.From = from;
args.To = null;
args.MessageText = chat;
args.Action = action;
args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerAnnouncemnt : ChatMessageEventArgs.ChatMessageTypes.PublicMessage;
MsgMessage msg = new MsgMessage();
msg.MessageText = chat;
msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID;
msg.To = PlayerConstants.AllPlayersID;
msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage;
Players.SendToAll(msg, false);
MessageSent?.Invoke(this, args);
}
public void TellMessage(string user, string message)
{
if (!IsAuthenticated)
{
throw new InvalidOperationException("Not authenticated. Request/set token first.");
}
if (AccountData == null)
{
throw new InvalidOperationException("No account data requested. Request account data first.");
}
try
{
var jObject = new JObject();
jObject["chat_token"] = Token;
jObject["username"] = SelectedUser;
jObject["tell"] = user;
jObject["msg"] = message;
Requester.PostRequest(Methods.MessageOutlet, jObject);
MessageSent?.Invoke(this, new MessageEventArgs(new Message(string.Empty, Utilities.GetTime(), user, SelectedUser, string.Empty, message)));
}
catch (RequestException e)
{
ErrorOccured?.Invoke(this, new ErrorEventArgs(e));
}
}
private void OnMessageSent(string message, bool error = false, string reason = "")
{
MessageSent?.Invoke(this, new NpMessageEventArgs()
{
Message = message, Error = error, Reason = reason
});
}
/// <summary>
/// Sends the specified string to the server.
/// </summary>
/// <remarks>
/// Do not use this method directly except for stream initialization and closing.
/// </remarks>
/// <param name="xml">The string to send.</param>
/// <exception cref="ArgumentNullException">The xml parameter is null.</exception>
/// <exception cref="IOException">There was a failure while writing to the network.</exception>
private void Send(string xml)
{
if (xml == null)
{
throw new ArgumentNullException("xml");
}
// XMPP is guaranteed to be UTF-8.
byte[] buf = Encoding.UTF8.GetBytes(xml);
lock (_writeLock)
{
try
{
_stream.Write(buf, 0, buf.Length);
_messageId++;
MessageSent?.Invoke(this, new MessageSentEventArgs(xml));
}
catch
{
Authenticated = false;
Connected = false;
throw;
}
}
}
/// <summary>
/// 发送信息线程方法
/// </summary>
private void SendThreadFunc()
{
Trace.WriteLine("Open send data tunnel");
lock (this.asyncTcpClient)
{
while (this.asyncTcpClient.Connected)
{
if (msgs2send.Count > 0)
{
try
{
var data = msgs2send.Dequeue();
if (data != null)
{
this.asyncTcpClient.Send(data);
MessageSent?.Invoke(this, new Message(this.Encoding.GetString(data)));
}
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
}
else
{
Thread.Sleep(200);
}
}
}
}
public async Task MulticastAsync(IdentityHash destinationId, byte[] payload)
{
byte[] symmetricKey;
if (!identity.IdentityManager.TryLookupMulticastKey(destinationId, out symmetricKey))
{
throw new InvalidStateException("Attempted to multicast to destination of unknown key!");
}
var messageDto = identity.EncodePacket(payload, symmetricKey);
var localInsertionResult = await localMerkleTree.TryInsertAsync(messageDto).ConfigureAwait(false);
if (localInsertionResult.Item1)
{
// "Decrypt the message"
MessageSent?.Invoke(new MessageReceivedEventArgs(
null,
new BroadcastMessage {
SourceId = IdentityHash.GetFlyweight(identity.PublicIdentityHash),
DestinationId = destinationId,
DecryptedPayload = payload,
Dto = messageDto
}
));
}
}
/// <summary>
/// Sends the specified string to the server.
/// </summary>
/// <remarks>
/// Do not use this method directly except for stream initialization and closing.
/// </remarks>
/// <param name="message">The string to send.</param>
/// <exception cref="ArgumentNullException">The xml parameter is null.</exception>
/// <exception cref="IOException">There was a failure while writing to the network.</exception>
private void Send(string message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
// Attach carriage return character if not present
if (!message.EndsWith("\r"))
{
message += "\r";
}
byte[] buf = Encoding.ASCII.GetBytes(message);
lock (_writeLock)
{
try
{
_stream.Write(buf, 0, buf.Length);
MessageSent?.Invoke(this, new MessageSentEventArgs(message));
}
catch
{
Close();
throw;
}
}
}
/// <summary>
/// Sends given message to host asynchronously using TcpClient with given cancellation token.
/// </summary>
/// <remarks>
/// Sunricher device does not accept messages with interval less than ~100ms, so this method will not run in parallel.
/// Internally uses queue to send one message at time.
/// </remarks>
/// <exception cref="OperationCanceledException">Operation was cancelled during connection to device.</exception>
public async Task SendMessageAsync(Byte[] message, CancellationToken cancellationToken)
{
void SendMessageAction()
{
if (cancellationToken.IsCancellationRequested)
{
return; //Return if already cancelled
}
var eventArgs = new LedMessageEventArgs(message);
SendingMessage?.Invoke(this, eventArgs);
if (_tcpClient == null)
{
_tcpClient = new TcpClient();
_tcpClient.ConnectAsync(_host, _port).Wait(cancellationToken); //Will throw if cancelled during connection
}
var writeTask = _tcpClient
.GetStream()
.WriteAsync(message, 0, message.Length, cancellationToken);
// ReSharper disable MethodSupportsCancellation
writeTask.Wait();
MessageSent?.Invoke(this, eventArgs);
if (writeTask.Status == TaskStatus.RanToCompletion)
{
Task.Delay(DelayAfterMessage).Wait();
}
// ReSharper restore MethodSupportsCancellation
}
await _serialQueue.Enqueue(SendMessageAction);
}
public void SendChatToUser(ServerPlayer from, ServerPlayer to, string chat, bool action)
{
if (chat == string.Empty)
{
return;
}
ChatMessageEventArgs args = new ChatMessageEventArgs();
args.From = from;
args.To = to;
args.ToTeam = to.ActualTeam;
args.MessageText = chat;
args.Action = action;
args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerPrivateMessage : ChatMessageEventArgs.ChatMessageTypes.PrivateMessage;
if (args.To == null)
{
return;
}
MsgMessage msg = new MsgMessage();
msg.MessageText = chat;
msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID;
msg.To = to.PlayerID;
msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage;
to.SendMessage(true, msg);
MessageSent?.Invoke(this, args);
}
private void OnServerMessageSent(object sender, int bytesSent)
{
MessageSent?.Invoke(this, new ConnectionMessageEventArgs()
{
Source = UniqueId, Message = $"{bytesSent}", Type = MessageType.Text
});
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
protected virtual void OnMessageSent(ConsoleMessageEventArgs e)
{
if (MessageSent != null)
{
MessageSent.Invoke(this, e);
}
}
async Task StartRunningLoop(CancellationToken ctx)
{
while (_chatClient != null && !ctx.IsCancellationRequested)
{
try
{
if (_conversation == null || string.IsNullOrEmpty(_conversation?.ConversationId))
{
throw new FieldAccessException(nameof(Conversation.ConversationId));
}
while (!string.IsNullOrEmpty(_channelAccount.Id) && _outputActivities.TryDequeue(out var outputActivity))
{
var response = await _chatClient.Conversations.PostActivityAsync(_conversation.ConversationId, outputActivity, ctx);
MessageSent?.Invoke(this, outputActivity.Text);
}
}
catch (Exception exception)
{
Error?.Invoke(this, exception);
}
await Task.Delay(200, ctx).ConfigureAwait(false);
}
}
private void HandleMessages()
{
while (Thread.CurrentThread.IsAlive)
{
if (hasMessages)
{
int messageCount = messageQueue.Count;
int messagesToTake = messageCount > MessagesToTakeFromQueueEachFrame
? MessagesToTakeFromQueueEachFrame
: messageCount;
BaseMessage[] messages;
lock (messageQueue)
{
messages = messageQueue.Dequeue(messagesToTake);
}
foreach (var message in messages)
{
MessageSent?.Invoke(this, message);
}
hasMessages = messageQueue.Count > 0;
}
Thread.Sleep(16);
}
}
protected virtual void OnError(string message)
{
var e = MessageEventArgs.Error(message);
MessageSent?.Invoke(this, e);
throw new InvalidOperationException();
}
void _sendThread()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
while (ThreadsRunning)
{
try
{
if (outputString.Count > 0 && Connected)
{
string message = OutputString;
lastmessage = message;
if (!String.IsNullOrEmpty(message))
{
byte[] buffer = Encoding.UTF8.GetBytes(message);
stream.Write(buffer, 0, buffer.Length);
MessageSent?.Invoke(this, new MessageSentEventArgs(message));
}
}
}
catch
{
continue;
}
Thread.Sleep(100);
}
}
// simple mail to 1 recepient w/o attachments
public bool Send(string to, string subject, string body)
{
MessageID = Guid.NewGuid();
using (var smtpClient = new SmtpClient()
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(SystemMailAddress, SystemMailFromPassword)
})
{
using (var mailMsg = new MailMessage())
{
mailMsg.From = new MailAddress(SystemMailAddress, SystemFromName);
mailMsg.Subject = subject;
mailMsg.Body = body;
mailMsg.IsBodyHtml = true;
mailMsg.To.Add(to);
smtpClient.Credentials = new System.Net.NetworkCredential(SystemMailAddress, SystemMailFromPassword);
smtpClient.Send(mailMsg);
if (MessageSent != null)
{
MessageSent.Invoke(MessageID, mailMsg);
}
}
}
return(true);
}
protected virtual void OnRatesUpdated(MessageEventArgs e)
{
if (MessageSent != null)
{
MessageSent.Invoke(this, e);
}
}
static Chat()
{
ChatSubmitMessage.Subscribe(data =>
{
var eventArgs = new ChatMessageEventArgs(G.Sys.PlayerManager_.Current_.profile_.Name_, data.message_);
MessageSent?.Invoke(null, eventArgs);
});
ChatMessage.Subscribe(data =>
{
Console.WriteLine(data.message_);
var author = ExtractMessageAuthor(data.message_);
if (author != G.Sys.PlayerManager_.Current_.profile_.Name_ && !IsSystemMessage(data.message_))
{
var eventArgs = new ChatMessageEventArgs(author, ExtractMessageBody(data.message_));
MessageReceived?.Invoke(null, eventArgs);
}
});
ToAllClientsRemotePlayerActionMessage.Subscribe(data =>
{
if (G.Sys.NetworkingManager_.IsOnline_)
{
var nickname = G.Sys.PlayerManager_.PlayerList_[data.index_].Username_;
var eventArgs = new ChatActionEventArgs(data.index_, nickname, data.message_);
ActionReceived?.Invoke(null, eventArgs);
}
});
}
public async ValueTask <bool> Send(Message message, HashSet <long> receivers)
{
using var context = Context;
message.ObjectId = IdGenerator.CreateId();
message.CreateUtcTime = DateTime.UtcNow;
message.Receivers = receivers.ToList();
var messageBox = new MessageBox(context);
context.BeginTran();
try
{
if (!await messageBox.AddMessage(message) ||
!await messageBox.SendMessage(message.ObjectId, message.Receivers))
{
context.RollbackTran();
return(false);
}
context.CommitTran();
MessageSent?.Invoke(this, message);
return(true);
}
catch (Exception e)
{
context.RollbackTran();
throw;
}
}
protected void onMessageSent(ClientConnection connection, Message msg)
{
this.control.Invoke((MethodInvoker)(() =>
{
MessageSent?.Invoke(this, msg);
}));
}
public void SendMessage(string message)
{
_fridaDispatcher.BeginInvoke((Action)(() =>
{
_script.Post(message);
MessageSent?.Invoke();
}));
}
public async Task SendAsync(byte[] buffer, IPEndPoint endpoint)
{
if (SendAsynchronously)
{
await Task.Yield();
}
MessageSent?.Invoke(buffer, endpoint);
}
public void Start()
{
foreach (var sequence in GetMessageSequence())
{
MessageSent?.Invoke(this, new MessageSentEventArgs(sequence.Message));
Thread.Sleep(sequence.WaitSpan);
}
}
public void SendMessage(string message, NLog.LogLevel logLevel = null)
{
if (logLevel == null)
{
logLevel = NLog.LogLevel.Info;
}
MessageSent?.Invoke(message, logLevel);
}
/// <summary>
/// Sends the oldest message in the queue to the CAN.
/// </summary>
private static void SendNextInQueue()
{
if (messageQueue.Count > 0)
{
int error = 0;
C4UFX.CANMessage mess = messageQueue.Dequeue();
C4UFX.SendCANMess(0, 0, mess, out error);
MessageSent?.Invoke(mess);
}
}
private void SendMessage()
{
if (!tbInput.Text.IsNullOrWhitespace())
{
MessageSent?.Invoke(tbInput.Text.Trim());
AppendMessageFromThisUser(tbInput.Text.Trim());
tbInput.Text = "";
tbInput.SelectionStart = 0;
}
}
/// <summary>
/// Sends a message to the currently connected stranger.
/// </summary>
/// <param name="message">Message content to be sent.</param>
public void SendMessage(string message)
{
if (IsReady && IsOpen && IsStrangerConnected)
{
SendPacket(new MessagePacket(message, CurrentContactUID));
var eventArgs = new MessageEventArgs(new Message(message, -1, -1, MessageType.Chat));
MessageSent?.Invoke(this, eventArgs);
ActionID++;
}
}
public void Send(Message message)
{
if (message == null)
{
return;
}
if (message.TargetId == Id)
{
SaveStateMessageIfNeeded(message);
}
MessageSent?.Invoke(message);
}
