/// <summary>
/// Handles the <see cref="EventingBasicConsumer.Received"/> event
/// </summary>
/// <param name="sender">The <see cref="object"/> representation of the instance raising the event</param>
/// <param name="basicDeliverEventArgs">The <see cref="BasicDeliverEventArgs"/> instance containing the event data</param>
private void OnDataReceived(object sender, BasicDeliverEventArgs basicDeliverEventArgs)
{
var correlationId = basicDeliverEventArgs?.BasicProperties?.CorrelationId ?? string.Empty;
FeedLog.Info($"Received message from MTS with correlationId: {correlationId}.");
ChannelMessageReceived?.Invoke(this, basicDeliverEventArgs);
if (!_channelSettings.UserAcknowledgmentEnabled)
{
var i = 0;
while (i < 10)
{
i++;
try
{
var channelWrapper = _channelFactory.GetChannel(UniqueId);
CreateAndOpenConsumerChannel();
channelWrapper.Channel.BasicAck(basicDeliverEventArgs?.DeliveryTag ?? 0, false);
break;
}
catch (Exception e)
{
if (!e.Message.Contains("unknown delivery tag"))
{
FeedLog.Debug($"Sending Ack for processed message {basicDeliverEventArgs?.DeliveryTag} failed. {e.Message}");
}
Thread.Sleep(i * 1000);
}
}
}
}
private void HandleChannelMessage(ServerCommand command, string character)
{
var sender = characterManager.GetCharacter(character);
if (sender.IsIgnored)
{
return;
}
var channel = channelManager.JoinedChannels[command.Value <string>("channel")];
var message = command.Value <string>("message");
switch (command.Type)
{
case ServerCommandType.MSG:
ChannelMessageReceived?.Invoke(channel, CreateMessage(sender, command.Time, WebUtility.HtmlDecode(message)));
break;
case ServerCommandType.LRP:
ChannelMessageReceived?.Invoke(channel, new Message(Message.Type.Ad, sender, command.Time, WebUtility.HtmlDecode(message)));
break;
case ServerCommandType.RLL:
ChannelMessageReceived?.Invoke(channel, new Message(Message.Type.Roll, sender, command.Time, message.Substring(message.IndexOf("[/user]" + 7))));
break;
}
}
//Todo: refactor
private void DataReceived(object sender, byte[] messageBytes)
{
var message = MessageFactory.Create(messageBytes);
if (message.MessageType == MessageType.Channel)
{
var channelMessage = (ChannelMessage)message;
var channelMessageClient = new ChannelMessageClient()
{
Channel = channelMessage.Channel, MessageString = channelMessage.MessageString
};
ChannelMessageReceived?.Invoke(this, channelMessageClient);
ChannelMessageClient.Add(channelMessageClient); //Remove: testing only
}
else if (message.MessageType == MessageType.ChannelUnavailable)
{
var channelMessage = (ChannelUnavailableMessage)message;
var channelMessageClient = new ChannelMessageClient()
{
Channel = channelMessage.Channel, MessageString = channelMessage.MessageString
};
ChannelMessageReceived?.Invoke(this, channelMessageClient);
ChannelMessageClient.Add(channelMessageClient); //Remove: testing only
}
else if (message.MessageType == MessageType.GetChannels)
{
var requestChannelsMessage = (RequestChannelsMessage)message;
ChannelListMessageReceived?.Invoke(this, requestChannelsMessage.Channels);
ChannelListMessageClient = requestChannelsMessage.Channels; //Remove: testing only
}
}
public void SendChannelMessage(ChannelCommand command, int midiChannel, byte data1)
{
ChannelMessageReceived?.Invoke(this, new ChannelMessageEventArgs(new ChannelMessage(command, midiChannel, data1)));
}
public override ACKResponse Start()
{
ChannelMessageReceived?.Invoke(Request.ChannelName, Request.Message);
return(new ACKResponse(Request));
}
/// <summary>
/// Raises the <see cref="ChannelMessageReceived"/> event.
/// </summary>
/// <param name="e">The <see cref="EventArgs"/> instance holding the event data.</param>
internal void OnChannelMessageReceived(IrcChannelMessageEventArgs e)
{
ChannelMessageReceived?.Invoke(this, e);
}
public void SendAd(Channel channel, string ad)
{
chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.LRP, new { channel = channel.Id, message = ad }));
ChannelMessageReceived?.Invoke(channel, new Message(Message.Type.Ad, characterManager.OwnCharacter, DateTime.Now, ad));
}
public void SendMessage(Channel channel, string message)
{
chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.MSG, new { channel = channel.Id, message }));
ChannelMessageReceived?.Invoke(channel, CreateMessage(characterManager.OwnCharacter, DateTime.Now, message));
SetCanSendMessages();
}
public virtual void Events_ReceivedTriggeringEvent(object sender, Entities.EventHandlers.ReceivedEventEventArgs e)
{
switch (e.Event.GetType().Name)
{
case nameof(FChatSharpLib.Entities.Events.Server.JoinChannel):
var jchEvent = (FChatSharpLib.Entities.Events.Server.JoinChannel)e.Event;
UserJoinedChannel?.Invoke(this, jchEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.InitialChannelData):
var ichEvent = (FChatSharpLib.Entities.Events.Server.InitialChannelData)e.Event;
BotJoinedChannel?.Invoke(this, ichEvent);
if (numberOfChannelsToTreatAsNewlyCreatedChannel > 0)
{
numberOfChannelsToTreatAsNewlyCreatedChannel--;
BotCreatedChannel?.Invoke(this, ichEvent);
}
break;
case nameof(FChatSharpLib.Entities.Events.Server.ConnectedUsers):
var conEvent = (FChatSharpLib.Entities.Events.Server.ConnectedUsers)e.Event;
BotConnected?.Invoke(this, new Entities.EventHandlers.ReceivedStateUpdateEventArgs()
{
State = State
});
break;
case nameof(FChatSharpLib.Entities.Events.Server.StatusChanged):
var staEvent = (FChatSharpLib.Entities.Events.Server.StatusChanged)e.Event;
UserChangedStatus?.Invoke(this, staEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.OnlineNotification):
var nlnEvent = (FChatSharpLib.Entities.Events.Server.OnlineNotification)e.Event;
UserLoggedOn?.Invoke(this, nlnEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.OfflineNotification):
var flnEvent = (FChatSharpLib.Entities.Events.Server.OfflineNotification)e.Event;
UserLoggedOff?.Invoke(this, flnEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.LeaveChannel):
var lchEvent = (FChatSharpLib.Entities.Events.Server.LeaveChannel)e.Event;
UserLeftChannel?.Invoke(this, lchEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.AddedChanOP):
var coaEvent = (FChatSharpLib.Entities.Events.Server.AddedChanOP)e.Event;
AddedOPInChannel?.Invoke(this, coaEvent);
break;
case nameof(FChatSharpLib.Entities.Events.Server.RemovedChanOP):
var corEvent = (FChatSharpLib.Entities.Events.Server.RemovedChanOP)e.Event;
RemovedOPInChannel?.Invoke(this, corEvent);
break;
case nameof(Entities.Events.Server.RollResult):
var rllEvent = (FChatSharpLib.Entities.Events.Server.RollResult)e.Event;
RollResultReceived?.Invoke(this, rllEvent);
break;
case nameof(Entities.Events.Server.Message):
var msgEvent = (FChatSharpLib.Entities.Events.Server.Message)e.Event;
ChannelMessageReceived?.Invoke(this, msgEvent);
break;
case nameof(Entities.Events.Server.PrivateMessage):
var prvEvent = (FChatSharpLib.Entities.Events.Server.PrivateMessage)e.Event;
PrivateMessageReceived?.Invoke(this, prvEvent);
break;
default:
break;
}
}
