public void AddMessage(Message message)
{
Message[] M;
Message removedMessage = null;
lock (MessageLock)
{
if (Messages.Length == maxMessages)
{
removedMessage = Messages[0];
M = new Message[maxMessages];
Array.Copy(Messages, 1, M, 0, Messages.Length - 1);
}
else
{
M = new Message[Messages.Length + 1];
Array.Copy(Messages, M, Messages.Length);
}
M[M.Length - 1] = message;
Messages = M;
MessageCount = M.Length;
}
MessageAdded?.Invoke(this, new MessageAddedEventArgs(message, removedMessage));
}
public void AddMessage(ISmtp4devMessage message)
{
if (_messages.TryAdd(message.Id, message))
{
MessageAdded?.Invoke(this, new Smtp4devMessageEventArgs(message));
}
}
public void OnMessageAdd(IMessage message)
{
if (message.Author == TwilioHelper.Identity)
{
return;
}
if (message.MessageBody.StartsWith("attach:", StringComparison.InvariantCulture))
{
MessageAdded?.Invoke(new Message
{
IsIncoming = true,
MessageDateTime = DateTime.Parse(message.TimeStamp),
Text = "I am here",
AttachementUrl = message.MessageBody.Replace("attach:", string.Empty)
});
}
else
{
MessageAdded?.Invoke(new Message
{
IsIncoming = true,
MessageDateTime = DateTime.Parse(message.TimeStamp),
Text = message.MessageBody
});
}
}
public void LogMessage(string message)
{
_messages.Add(message);
MostRecentMessage = message;
MessageAdded?.Invoke(this, new EventArgs());
CheckWrite(message);
}
/// <summary>
/// Add the message or image stored in newMessage to the conversations list
/// </summary>
public void AddToConversation()
{
Conversation.Add(newMessage);
LastReceivedMessageTime = DateTime.Now;
fixVisibleCollection();
MessageAdded.Invoke();
StoreConversation();
}
public void AddMessage(Message message)
{
lock (this) {
_messages.Add(message);
}
MessageAdded?.Invoke(this, new AddedEventArg(message));
}
public void AddMessages(List <Message> messages)
{
foreach (var message in messages)
{
Storage.Add(message);
MessageAdded?.Invoke();
}
}
public void AddRoomMessage(string roomID, string author, string message)
{
RoomMessage roomMessage = CreateChatboxMessage(author, message);
Room room = (Room)GetRoom(roomID);
room.AddMessage(roomMessage);
MessageAdded?.Invoke(room, roomMessage);
Console.WriteLine("Message added in RoomID : " + room.ID + " \n Author : " + roomMessage.Author + " \n Message : " + roomMessage.Message);
}
public void Apply(MessageAdded aggregateEvent) //Event anwenden
{
if (Messages == null)
{
Messages = new List <Message>();
}
Messages.Add(aggregateEvent.Message);
}
public void AddMessage(ISmtp4devMessage message)
{
lock (_syncRoot)
{
_database.Store(message);
_database.Commit();
}
MessageAdded?.Invoke(this, new Smtp4devMessageEventArgs(message));
}
public HostState Apply(MessageAdded data)
{
var message = new Message(
data.Id, data.Text,
data.ById, data.On);
return(new HostState(
Users,
Messages.Add(message)
));
}
public void AddMessage(ChatMessage message)
{
if (messages.Count == MESSAGE_LIMIT)
{
messages.RemoveAt(0);
}
messages.Add(message);
MessageAdded?.Invoke(this, new IRCMessageEventArgs(message));
}
public void PublishMessageAdded(Guid messageId, string text)
{
var evt = new MessageAdded
{
MessageId = messageId,
Text = text
};
_publisher.Publish(evt, _messageContext.ReplyTo ?? string.Empty, new Guid(_messageContext.CorrelationId), _contentType).Wait();
Console.WriteLine($"MessageAdded published. Id={messageId}, CorrelationId = {_messageContext.CorrelationId}");
}
private async void AddMessage(IRoom room, IRoomMessage roomMessage)
{
List <ChatBox> chatBoxLinkedToRoomList = _chatBoxList.Where(x => x.ID == room.ID).ToList();
var addedChatBoxMessageList = new List <ChatBoxMessage>();
ChatBoxMessage chatBoxMessage;
chatBoxLinkedToRoomList.ForEach(y =>
{
chatBoxMessage = CreateChatBoxMessage(roomMessage.Author, roomMessage.Message);
y.RoomMessageList.Add(chatBoxMessage);
MessageAdded?.Invoke(y, chatBoxMessage);
});
}
/// <summary>
/// Adds a message to the log
/// </summary>
/// <param name="message">The message to add</param>
/// <param name="logLevel">The LogLevel of the message, indicating its severity</param>
/// <param name="ex">The caught exception</param>
/// <returns></returns>
public async Task WriteAsync(string message, LogLevel logLevel, Exception exception = null)
{
MessageAdded?.Invoke(this, new LogMessageEventArgs {
Message = message, LogLevel = logLevel, Exception = exception
});
Protocol.Messages.Add(new ProtocolItem
{
Message = message,
LogLevel = logLevel,
Exception = exception
});
}
public void Trigger()
{
ConsolidateCache();
lock (syncLock)
{
foreach (var m in MessageCache)
{
MessageAdded?.Invoke(null, m);
if (m.Intent == SpeckleGSAInterfaces.MessageIntent.TechnicalLog)
{
this.LoggedMessageCount++;
}
}
MessageCache.Clear();
}
}
private void OnMessage(object sender, MsgHandlerEventArgs e)
{
var url = e.Message.ArrivalSubscription.Connection.ConnectedUrl;
NatsMessage msg = new NatsMessage
{
MessageType = MessageType.Received,
TimeStamp = DateTime.Now,
Subject = e.Message.Subject,
Data = Encoding.Default.GetString(e.Message.Data),
Url = url
};
Messages.Add(msg);
MessageReceived?.Invoke(msg);
MessageAdded?.Invoke(msg);
}
private void HandleNewMessage(FirebaseObject <Message> message)
{
// if Object is null, that is the Firebase.Database way of telling us the collection is empty, so ignore here
if (message.Object != null)
{
if (_messageDictionary.ContainsKey(message.Key))
{
_messageDictionary[message.Key].Text = message.Object.Text;
}
else
{
_messageDictionary[message.Key] = message.Object;
_messages.Add(message.Object);
MessageAdded?.Invoke(this, null);
}
}
}
public void Message(LogLevel level, string message, params object[] formatArgs)
{
var logMessage = new MemoryLogMessage()
{
Timestamp = DateTime.Now, Level = level
};
if (formatArgs?.Length > 0)
{
logMessage.Message = string.Format(message, formatArgs);
}
else
{
logMessage.Message = message;
}
log.Add(logMessage);
MessageAdded?.Invoke(this, new MemoryLogMessageEventArgs(logMessage));
}
public ChatMessage AddMessage(string username, string message)
{
if (string.IsNullOrWhiteSpace(username))
{
throw new ArgumentException("No username specified");
}
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentException("No message specified");
}
username = username.Trim();
var now = DateTime.UtcNow;
var m = new ChatMessage {
Username = username,
Message = message.Trim(),
UtcTime = now,
};
messages.Enqueue(m);
while (messages.Count > 32)
{
messages.TryDequeue(out var _);
}
MessageAdded?.Invoke(this, new MessageEventArgs(m));
if (!users.ContainsKey(username))
{
var u = new ChatUser {
Username = username,
};
if (users.TryAdd(username, u))
{
UserAdded?.Invoke(this, new UserEventArgs(u));
}
}
return(m);
}
public void Publish(NatsMessage message)
{
Logger.Info($"{nameof(Publish)}: {message.Subject}, {message.Url}");
var conn = ConnectionsByName.Values.FirstOrDefault(c => c.ConnectedUrl == message.Url);
if (conn != null)
{
conn.Publish(message.Subject, Encoding.Default.GetBytes(message.Data));
MessageSent?.Invoke(message);
var clone = message.Clone();
clone.MessageType = MessageType.Publish;
Messages.Add(clone);
MessageAdded?.Invoke(clone);
}
else
{
Logger.Error($"Can't find connection with Url: {message.Url} !");
}
}
public NatsMessage Request(NatsMessage message, int timeoutMs = 1000)
{
Logger.Info($"{nameof(Publish)}: {message.Subject}, {message.Url}");
var conn = ConnectionsByName.Values.FirstOrDefault(c => c.ConnectedUrl == message.Url);
if (conn != null)
{
try
{
var payload = message.Data == null ? new byte[0] : Encoding.Default.GetBytes(message.Data);
Msg reply = conn.Request(message.Subject, payload, timeoutMs);
var clone = message.Clone();
clone.MessageType = MessageType.Request;
Messages.Add(clone);
MessageAdded?.Invoke(clone);
MessageSent?.Invoke(message);
var replyMsg = new NatsMessage
{
MessageType = MessageType.Reply,
Subject = reply.Subject,
TimeStamp = DateTime.Now,
Data = Encoding.Default.GetString(reply.Data)
};
Messages.Add(replyMsg);
MessageAdded?.Invoke(replyMsg);
return(replyMsg);
}
catch (Exception ex)
{
Logger.Error($"Failed to send request message ! {ex.Message}");
}
}
else
{
Logger.Error($"Can't find connection with Url: {message.Url} !");
}
return(null);
}
public void AddMessage(IEnumerable <Message> messages, ChatterUser user)
{
if (user.AgregatorUser != null)
{
if (messages.Any(x => x.Recived))
{
user.AgregatorUser.ActiveDialog = user;
user.AgregatorUser.DialogExpire = DateTime.Now + user.ResponseTime;
}
else
{
//if first output message
if (user.AgregatorUser.ActiveDialog == user && user.Messages.Last().Recived)
{//no update StartTime, just doble existing waiting time;
user.AgregatorUser.DialogExpire += user.ResponseTime;
}
}
}
//user = ChatterUsers.First(x => x.UserId == user.UserId);
user.Messages.AddRange(messages);
MessageAdded?.Invoke(messages, user);
}
protected void OnMessageAdded(string message)
{
MessageAdded?.Invoke(message);
}
public void Add(IMessage message)
{
Messages.Add(message);
MessageAdded?.Invoke();
}
public void Add(SyslogMessage message)
{
_queue.Enqueue(message);
MessageAdded?.Invoke(this, EventArgs.Empty);
}
public void AddMessage(Message message)
{
messages.Add(message);
MessageAdded?.Invoke(message);
}
protected virtual void OnMessageAdded()
{
MessageAdded?.Invoke(this, EventArgs.Empty);
}
public void AddMessage(Message msg)
{
Messages.Add(msg);
MessageAdded?.Invoke();
}
private void SubscribeToEvents()
{
_subscriptions.Apply(x => x.Dispose());
_subscriptions.Clear();
#region Channel
_subscriptions.Add(_connection.On <ChannelSummaryResponse>(ClientEvents.ChannelUpdated,
channel =>
{
ChannelUpdated?.Invoke(channel);
}));
_subscriptions.Add(_connection.On <Guid>(ClientEvents.ChannelClosed,
channelId =>
{
ChannelClosed?.Invoke(channelId);
}));
#endregion
#region Message
_subscriptions.Add(_connection.On <MessageResponse>(ClientEvents.MessageAdded,
message =>
{
MessageAdded?.Invoke(message);
}));
_subscriptions.Add(_connection.On <MessageResponse>(ClientEvents.MessageUpdated,
message =>
{
MessageUpdated?.Invoke(message);
}));
_subscriptions.Add(_connection.On <Guid, Guid>(ClientEvents.MessageDeleted,
(deletedMessageId, channelId) =>
{
MessageDeleted?.Invoke(deletedMessageId, channelId);
}));
_subscriptions.Add(_connection.On <Guid>(ClientEvents.LastReadMessageChanged,
channelId =>
{
LastReadMessageUpdated?.Invoke(channelId);
}));
#endregion
#region Member
_subscriptions.Add(_connection.On <ChannelSummaryResponse>(ClientEvents.MemberJoined,
(channel) =>
{
MemberJoined?.Invoke(channel);
}));
_subscriptions.Add(_connection.On <Guid>(ClientEvents.MemberLeft,
(channelId) =>
{
MemberLeft?.Invoke(channelId);
}));
_subscriptions.Add(_connection.On <MemberSummaryResponse, Guid>(ClientEvents.MemberDeleted,
(member, channelId) =>
{
MemberDeleted?.Invoke(member, channelId);
}));
#endregion
}
