/// <summary>
/// Creates a new <see>UserEventArgs</see> with the specified settings.
/// </summary>
/// <param name="eventType">The type of chat event.</param>
/// <param name="user">A reference to the user involved in the event.</param>
public UserEventArgs(ChatEventType eventType, ChatUser user)
: base(eventType)
{
Debug.Assert(user != null);
m_user = user;
}
/// <summary>
/// Creates a new instance of <see>ChatMessageEventArgs</see> with the given parameters.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="flags">The other user's flags.</param>
/// <param name="username">The primarily involved user.</param>
/// <param name="text">The message.</param>
public ChatMessageEventArgs(ChatEventType eventType, UserFlags flags, string username, string text)
: base(eventType)
{
m_flags = flags;
m_un = username;
m_txt = text;
}
/// <summary>
/// Creates a new <see>UserEventArgs</see> with the specified settings.
/// </summary>
/// <param name="eventType">The type of chat event.</param>
/// <param name="user">A reference to the user involved in the event.</param>
public UserEventArgs(ChatEventType eventType, ChatUser user)
: base(eventType)
{
Debug.Assert(user != null);
m_user = user;
}
/// <summary>
/// Creates a new instance of <see>ChatMessageEventArgs</see> with the given parameters.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="flags">The other user's flags.</param>
/// <param name="username">The primarily involved user.</param>
/// <param name="text">The message.</param>
public ChatMessageEventArgs(ChatEventType eventType, TFlagsType flags, string username, string text)
: base(eventType)
{
_flags = flags;
_un = username;
_txt = text;
}
public ChatMessage(ChatEventType eventType, string channel, string messageId)
{
EventType = eventType;
SubscriptionId = channel;
ChannelId = channel.Split("_")[0];
MessageId = messageId;
}
public void OnChatEvent(ChatEventType type, params string[] args)
{
Invoke(new MethodInvoker(() => {
switch (type)
{
case ChatEventType.Message:
AppendText(String.Format("[{0:D2}:{1:D2}]{3} {4}", DateTime.Now.Hour, DateTime.Now.Minute, args[0], args[1]));
break;
case ChatEventType.UserJoin:
AppendText(String.Format("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has joined!\n", DateTime.Now.Hour, DateTime.Now.Minute, "".PadLeft(20), args[0]));
namesListBox.Items.Add(args [0]);
break;
case ChatEventType.UserPart:
AppendText(String.Format("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has left!\n", DateTime.Now.Hour, DateTime.Now.Minute, "".PadLeft(20), args [0]));
namesListBox.Items.Remove(args[0]);
break;
case ChatEventType.NickChange:
AppendText(String.Format("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has changed their nickname to \u001Bc1;{4}\u001Bc0;!\n",
DateTime.Now.Hour,
DateTime.Now.Minute,
"".PadLeft(20),
args[0],
args[1]));
namesListBox.Items.Remove(args[0]);
namesListBox.Items.Add(args[1]);
break;
}
}));
}
/// <summary>
/// Creates a new instance of <see>ChatMessageEventArgs</see> with the given parameters.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="flags">The other user's flags.</param>
/// <param name="username">The primarily involved user.</param>
/// <param name="text">The message.</param>
public ChatMessageEventArgs(ChatEventType eventType, UserFlags flags, string username, string text)
: base(eventType)
{
m_flags = flags;
m_un = username;
m_txt = text;
}
public ChatEvent( ChatEventType type, DateTime timestamp, ulong sourceUserId, ulong remoteUserId, string message, ushort priority )
{
Type = type;
Timestamp = timestamp;
SourceUserId = sourceUserId;
RemoteUserId = remoteUserId;
Message = message;
Priority = priority;
}
public static ChatEventDataModel Create(string actor, string userInvolvedId, ChatEventType eventType)
{
return(new ChatEventDataModel()
{
ActorId = actor,
UserInvolvedId = userInvolvedId,
EventType = eventType
});
}
public ChatEvent( DateTime timestamp, ulong remoteUserId, string message )
{
Timestamp = timestamp;
RemoteUserId = remoteUserId;
Message = message;
//Defaults
Type = ChatEventType.OnChatReceived;
SourceUserId = 0;
Priority = 0;
}
public async Task <MessageDataModel> AddChatEvent(ChatEventType type,
string actorId, string userInvolvedId, int chatId)
{
try
{
var newEvent = await chatEventsRepository.AddAsync(ChatEventDataModel.Create(actorId, userInvolvedId, type));
var model = MessageDataModel
.Create(null, chatId)
.AsEvent(newEvent);
var result = await messagesRepository.AddAsync(model);
await unitOfWork.Commit();
return(result);
}
catch (Exception e)
{
throw new InvalidDataException("Wrong actorId or userId", e);
}
}
public void ChatEvent(ChatClient cc, ChatEventType cet, object opt)
{
string[] sndstr = new string[2];
sndstr[0] = cet.ToString();
if (opt != null)
{
sndstr[1] = (string)opt;
}
switch (cet)
{
case ChatEventType.JOINED:
case ChatEventType.QUITTED:
sndstr[1] = cc.NickName;
break;
case ChatEventType.MSGG:
if (sndstr[1].Length > 512)
{
sndstr[1] = sndstr[1].Remove(512);
}
sndstr[0] += "\n" + cc.NickName;
break;
default:
break;
}
foreach (ChatClient c in clients)
{
if (cc.type == ChatClient.ClientType.SERVER && c.type == ChatClient.ClientType.SERVER)
{
continue; // forbid SERVER TO SERVER communication
}
c.SendMsg(sndstr);
}
}
/// <summary>
/// Creates a new <see>ServerChatEventArgs</see> with the specified information.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="flags">Event-specific flags that must be interpreted based on the event type.</param>
/// <param name="text">Informational message from the server.</param>
public ServerChatEventArgs(ChatEventType eventType, int flags, string text)
: base(eventType)
{
m_flags = flags;
m_txt = text;
}
// Methods
public ChatEvent(byte[] data) : base(data)
{
this.clientVersion = -1;
this.characterType = BattleNetCharacter.Unknown;
this.characterLevel = -1;
this.characterAct = -1;
this.characterTitle = CharacterTitle.None;
this.eventType = (ChatEventType)BitConverter.ToUInt32(data, 3);
this.flags = BitConverter.ToUInt32(data, 7);
this.ping = BitConverter.ToUInt32(data, 11);
int length = ByteConverter.GetByteOffset(data, 0, 0x1b);
int num2 = ByteConverter.GetByteOffset(data, 0x2a, 0x1b, length);
if (num2 > 0)
{
this.name = ByteConverter.GetString(data, 0x1b, num2);
length -= num2 + 1;
num2 += 0x1c;
}
else if (num2 == 0)
{
num2 = 0x1c;
length--;
this.characterType = BattleNetCharacter.OpenCharacter;
}
else
{
num2 = 0x1b;
}
this.account = ByteConverter.GetString(data, num2, length);
length += num2 + 1;
if (this.eventType != ChatEventType.ChannelLeave)
{
if ((this.eventType == ChatEventType.ChannelJoin) || (this.eventType == ChatEventType.ChannelUser))
{
if ((data.Length - length) > 3)
{
this.client = (BattleNetClient)BitConverter.ToUInt32(data, length);
length += 4;
}
if ((((this.client != BattleNetClient.StarcraftShareware) && (this.client != BattleNetClient.Starcraft)) && (this.client != BattleNetClient.StarcraftBroodWar)) && ((this.client == BattleNetClient.Diablo2) || (this.client == BattleNetClient.Diablo2LoD)))
{
if (this.client == BattleNetClient.Diablo2LoD)
{
this.characterFlags |= CharacterFlags.Expansion;
}
if ((data.Length - length) >= 4)
{
this.realm = ByteConverter.GetString(data, length, -1, 0x2c);
length += this.realm.Length + 1;
if (data.Length >= length)
{
length += ByteConverter.GetByteOffset(data, 0x2c, length) + 1;
if (((length != -1) && (data.Length > length)) && ((data.Length - length) >= 0x21))
{
StatString.ParseD2StatString(data, length, ref this.clientVersion, ref this.characterType, ref this.characterLevel, ref this.characterFlags, ref this.characterAct, ref this.characterTitle);
}
}
}
}
}
else
{
this.message = ByteConverter.GetNullString(data, length);
}
}
}
private void NoteTag(string tag, ChatUser chatUser, string currentChannel, ChatEventType action)
{
if (string.IsNullOrEmpty(tag))
return;
string act = "joining the channel";
switch (action)
{
case ChatEventType.UserInChannel:
act = "being seen in the channel";
break;
case ChatEventType.UserFlagsChanged:
act = "having flags updated in the channel";
break;
case ChatEventType.UserLeftChannel:
act = "leaving the channel";
break;
case ChatEventType.UserJoinedChannel:
act = "joining the channel";
break;
}
using (ClansDataContext dc = ClansDataContext.Create(m_dbPath))
{
if (dc.Clans.Where(c => c.Tag.ToUpper() == tag.ToUpper()).Count() == 0)
{
Clan c = new Clan
{
GatewayID = m_gatewayID,
Tag = tag,
DiscoverySource = string.Format("{0}, a Warcraft 3 user in {1}, {2}.", chatUser.Username, currentChannel, act)
};
dc.Clans.InsertOnSubmit(c);
try
{
dc.SubmitChanges();
m_client.MainWindow.AddChat(new ChatNode[] {
new ChatNode("JinxBot Clan Gnome added ", Color.DarkRed),
new ChatNode(c.DiscoverySource, Color.Yellow)
});
}
catch (Exception ex)
{
m_client.MainWindow.AddChat(new ChatNode[] {
new ChatNode("JinxBot Clan Gnome error ", Color.DarkRed),
new ChatNode("Error saving a new clan:", Color.Red),
ChatNode.NewLine,
new ChatNode(ex.ToString(), Color.OrangeRed)
});
}
}
else
{
m_client.MainWindow.AddChat(new ChatNode[] {
new ChatNode("JinxBot Clan Gnome note: ", Color.DarkRed),
new ChatNode("Already noted clan ", Color.Yellow),
new ChatNode(tag, Color.Lime)
});
}
}
}
/// <summary>
/// Initializes a new <see>ChatEventArgs</see>.
/// </summary>
/// <param name="eventType">The event type.</param>
protected ChatEventArgs(ChatEventType eventType)
{
m_evType = eventType;
}
public void OnChatEvent (ChatEventType type, params string[] args) {
Invoke (new MethodInvoker (() => {
switch (type) {
case ChatEventType.Message:
AppendText (String.Format ("[{0:D2}:{1:D2}]{3} {4}", DateTime.Now.Hour, DateTime.Now.Minute, args[0], args[1]));
break;
case ChatEventType.UserJoin:
AppendText (String.Format ("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has joined!\n", DateTime.Now.Hour, DateTime.Now.Minute, "".PadLeft (20), args[0]));
namesListBox.Items.Add (args [0]);
break;
case ChatEventType.UserPart:
AppendText (String.Format ("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has left!\n", DateTime.Now.Hour, DateTime.Now.Minute, "".PadLeft (20), args [0]));
namesListBox.Items.Remove (args[0]);
break;
case ChatEventType.NickChange:
AppendText (String.Format ("[{0:D2}:{1:D2}]{2} \u001Bc1;{3}\u001Bc0; has changed their nickname to \u001Bc1;{4}\u001Bc0;!\n",
DateTime.Now.Hour,
DateTime.Now.Minute,
"".PadLeft (20),
args[0],
args[1]));
namesListBox.Items.Remove (args[0]);
namesListBox.Items.Add (args[1]);
break;
}
}));
}
private void HandleChatEvent(ParseData data)
{
DataReader dr = new DataReader(data.Data);
ChatEventType type = (ChatEventType)dr.ReadInt32();
int flags = dr.ReadInt32();
int ping = dr.ReadInt32();
dr.Seek(12);
string user = dr.ReadCString();
byte[] userInfo = dr.ReadNullTerminatedByteArray();
string text = Encoding.ASCII.GetString(userInfo);
switch (type)
{
case ChatEventType.UserInChannel:
case ChatEventType.UserJoinedChannel:
ChatUser newUser = new ChatUser(user, ping, (UserFlags)flags, UserStats.Parse(user, userInfo));
if (m_namesToUsers.ContainsKey(user))
{
m_namesToUsers.Remove(user);
}
m_namesToUsers.Add(user, newUser);
UserEventArgs uArgs = new UserEventArgs(type, newUser);
HandleUserChatEvent(uArgs);
break;
case ChatEventType.UserFlagsChanged:
if (m_namesToUsers.ContainsKey(user))
{
ChatUser changedUser = m_namesToUsers[user];
changedUser.Flags = (UserFlags)flags;
UserEventArgs updatedArgs = new UserEventArgs(type, changedUser);
HandleUserChatEvent(updatedArgs);
}
else if (m_channelName.Equals("The Void", StringComparison.OrdinalIgnoreCase))
{
ChatUser voidUser = new ChatUser(user, ping, (UserFlags)flags, UserStats.Parse(user, userInfo));
m_namesToUsers.Add(user, voidUser);
UserEventArgs voidArgs = new UserEventArgs(type, voidUser);
HandleUserChatEvent(voidArgs);
}
break;
case ChatEventType.UserLeftChannel:
if (m_namesToUsers.ContainsKey(user))
{
ChatUser goneUser = m_namesToUsers[user];
UserEventArgs leftArgs = new UserEventArgs(type, goneUser);
HandleUserChatEvent(leftArgs);
}
break;
case ChatEventType.Emote:
case ChatEventType.Talk:
case ChatEventType.WhisperReceived:
case ChatEventType.WhisperSent:
ChatMessageEventArgs cmArgs = new ChatMessageEventArgs(type, (UserFlags)flags, user, Encoding.UTF8.GetString(userInfo));
HandleChatMessageEvent(cmArgs);
break;
case ChatEventType.NewChannelJoined:
ServerChatEventArgs joinArgs = new ServerChatEventArgs(type, flags, text);
m_channelName = text;
m_namesToUsers.Clear();
OnJoinedChannel(joinArgs);
break;
case ChatEventType.Broadcast:
case ChatEventType.ChannelDNE:
case ChatEventType.ChannelFull:
case ChatEventType.ChannelRestricted:
case ChatEventType.Error:
case ChatEventType.Information:
ServerChatEventArgs scArgs = new ServerChatEventArgs(type, flags, text);
HandleServerChatEvent(scArgs);
break;
}
BattleNetClientResources.IncomingBufferPool.FreeBuffer(data.Data);
}
public UserChatMessage(ChatEventType eventType, string channel, string messageId, PublicUserData user, RoomRole roomRole, bool subscribing) : base(eventType, channel, messageId)
{
User = user;
RoomRole = roomRole;
Subscribing = subscribing;
}
// Methods
public ChatEvent(byte[] data)
: base(data)
{
this.clientVersion = -1;
this.characterType = BattleNetCharacter.Unknown;
this.characterLevel = -1;
this.characterAct = -1;
this.characterTitle = CharacterTitle.None;
this.eventType = (ChatEventType) BitConverter.ToUInt32(data, 3);
this.flags = BitConverter.ToUInt32(data, 7);
this.ping = BitConverter.ToUInt32(data, 11);
int length = ByteConverter.GetByteOffset(data, 0, 0x1b);
int num2 = ByteConverter.GetByteOffset(data, 0x2a, 0x1b, length);
if (num2 > 0)
{
this.name = ByteConverter.GetString(data, 0x1b, num2);
length -= num2 + 1;
num2 += 0x1c;
}
else if (num2 == 0)
{
num2 = 0x1c;
length--;
this.characterType = BattleNetCharacter.OpenCharacter;
}
else
{
num2 = 0x1b;
}
this.account = ByteConverter.GetString(data, num2, length);
length += num2 + 1;
if (this.eventType != ChatEventType.ChannelLeave)
{
if ((this.eventType == ChatEventType.ChannelJoin) || (this.eventType == ChatEventType.ChannelUser))
{
if ((data.Length - length) > 3)
{
this.client = (BattleNetClient) BitConverter.ToUInt32(data, length);
length += 4;
}
if ((((this.client != BattleNetClient.StarcraftShareware) && (this.client != BattleNetClient.Starcraft)) && (this.client != BattleNetClient.StarcraftBroodWar)) && ((this.client == BattleNetClient.Diablo2) || (this.client == BattleNetClient.Diablo2LoD)))
{
if (this.client == BattleNetClient.Diablo2LoD)
{
this.characterFlags |= CharacterFlags.Expansion;
}
if ((data.Length - length) >= 4)
{
this.realm = ByteConverter.GetString(data, length, -1, 0x2c);
length += this.realm.Length + 1;
if (data.Length >= length)
{
length += ByteConverter.GetByteOffset(data, 0x2c, length) + 1;
if (((length != -1) && (data.Length > length)) && ((data.Length - length) >= 0x21))
{
StatString.ParseD2StatString(data, length, ref this.clientVersion, ref this.characterType, ref this.characterLevel, ref this.characterFlags, ref this.characterAct, ref this.characterTitle);
}
}
}
}
}
else
{
this.message = ByteConverter.GetNullString(data, length);
}
}
}
/// <summary>
/// Creates a new <see>ServerChatEventArgs</see> with the specified information.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="flags">Event-specific flags that must be interpreted based on the event type.</param>
/// <param name="text">Informational message from the server.</param>
public ServerChatEventArgs(ChatEventType eventType, int flags, string text)
: base(eventType)
{
m_flags = flags;
m_txt = text;
}
/// <summary>
/// Initializes a new <see>ChatEventArgs</see>.
/// </summary>
/// <param name="eventType">The event type.</param>
protected ChatEventArgs(ChatEventType eventType)
{
m_evType = eventType;
}
private void HandleChatEvent(BncsReader dr)
{
if (_oldParseCallback != null)
{
_oldParseCallback(dr);
dr.Seek(-dr.Position);
dr.Seek(4);
}
ChatEventType type = (ChatEventType)dr.ReadInt32();
int flags = dr.ReadInt32();
int ping = dr.ReadInt32();
dr.Seek(12);
string user = dr.ReadCString();
byte[] userInfo = dr.ReadNullTerminatedByteArray();
string text = Encoding.ASCII.GetString(userInfo);
switch (type)
{
case ChatEventType.UserInChannel:
case ChatEventType.UserJoinedChannel:
ChatUser newUser = new ChatUser(user, ping, (ClassicUserFlags)flags, UserStats.Parse(user, userInfo));
if (_namesToUsers.ContainsKey(user))
{
_namesToUsers.Remove(user);
}
_namesToUsers.Add(user, newUser);
UserEventArgs <ChatUser> uArgs = new UserEventArgs <ChatUser>(type, newUser);
HandleUserChatEvent(uArgs);
break;
case ChatEventType.UserFlagsChanged:
if (_namesToUsers.ContainsKey(user))
{
ChatUser changedUser = _namesToUsers[user];
changedUser.Flags = (ClassicUserFlags)flags;
UserEventArgs <ChatUser> updatedArgs = new UserEventArgs <ChatUser>(type, changedUser);
HandleUserChatEvent(updatedArgs);
}
else if (_channelName.Equals("The Void", StringComparison.OrdinalIgnoreCase))
{
ChatUser voidUser = new ChatUser(user, ping, (ClassicUserFlags)flags, UserStats.Parse(user, userInfo));
_namesToUsers.Add(user, voidUser);
UserEventArgs <ChatUser> voidArgs = new UserEventArgs <ChatUser>(type, voidUser);
HandleUserChatEvent(voidArgs);
}
break;
case ChatEventType.UserLeftChannel:
if (_namesToUsers.ContainsKey(user))
{
ChatUser goneUser = _namesToUsers[user];
UserEventArgs <ChatUser> leftArgs = new UserEventArgs <ChatUser>(type, goneUser);
HandleUserChatEvent(leftArgs);
}
break;
case ChatEventType.Emote:
case ChatEventType.Talk:
case ChatEventType.WhisperReceived:
case ChatEventType.WhisperSent:
ChatMessageEventArgs <UserFlags> cmArgs = new ChatMessageEventArgs <UserFlags>(type, (UserFlags)flags, user, Encoding.UTF8.GetString(userInfo));
HandleChatMessageEvent(cmArgs);
break;
case ChatEventType.NewChannelJoined:
ServerChatEventArgs joinArgs = new ServerChatEventArgs(type, flags, text);
_channelName = text;
_namesToUsers.Clear();
OnJoinedChannel(joinArgs);
break;
case ChatEventType.Broadcast:
case ChatEventType.ChannelDNE:
case ChatEventType.ChannelFull:
case ChatEventType.ChannelRestricted:
case ChatEventType.Error:
case ChatEventType.Information:
ServerChatEventArgs scArgs = new ServerChatEventArgs(type, flags, text);
HandleServerChatEvent(scArgs);
break;
}
}
