public override void HandleMessage(Streams.XmppStream stream, Message msg, XmppHandlerContext context)
{
//Private msg
if (msg.Type==MessageType.chat)
{
if (Member.ResolveRoomJid(msg.From)==null)
{
//Error
msg.SwitchDirection();
msg.From = Member.RoomFrom;
msg.Type = MessageType.error;
msg.Error = new Error(ErrorCondition.ItemNotFound);
context.Sender.SendTo(stream, msg);
}
else
{
//Send
msg.To = Member.RealJid;
msg.From = Member.ResolveRoomJid(msg.From);
Member.Send(msg);
}
}
else
{
msg.SwitchDirection();
msg.From = Member.RoomFrom;
msg.Type = MessageType.error;
msg.Error = new Error(ErrorCondition.BadRequest);
context.Sender.SendTo(stream, msg);
}
}
public override void HandleMessage(XmppStream stream, Message msg, XmppHandlerContext context)
{
msg.SwitchDirection();
msg.Type = MessageType.error;
msg.Error = new Error(ErrorType.cancel, ErrorCondition.ItemNotFound);
context.Sender.SendTo(stream, msg);
}
private void StoreOffline(Message message, IOfflineStore offlineStore)
{
if ((message.Type == MessageType.normal || message.Type == MessageType.chat) && !string.IsNullOrEmpty(message.To.User))
{
offlineStore.SaveOfflineMessages(message);
}
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
if (!message.HasTo) return;
if (archiveStore.GetMessageLogging(message.From, message.To))
{
if (!string.IsNullOrEmpty(message.Body) ||
!string.IsNullOrEmpty(message.Subject) ||
!string.IsNullOrEmpty(message.Thread) ||
message.Html != null)
{
var flush = false;
lock (messageBuffer)
{
//Add xdelay
if (message.XDelay == null)
{
message.XDelay = new Delay();
message.XDelay.Stamp = DateTime.UtcNow;
}
messageBuffer.Add(message);
flush = BUFFER_SIZE <= messageBuffer.Count;
}
if (flush) FlushMessageBuffer();
}
}
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
if (!message.HasTo) return;
if (archiveStore == null)
{
archiveStore = new DbMessageArchive();
var properties = new Dictionary<string, string>(1);
properties.Add("connectionStringName", "core");
archiveStore.Configure(properties);
}
if (archiveStore.GetMessageLogging(message.From, message.To))
{
if (!string.IsNullOrEmpty(message.Body) ||
!string.IsNullOrEmpty(message.Subject) ||
!string.IsNullOrEmpty(message.Thread) ||
message.Html != null)
{
var flush = false;
lock (messageBuffer)
{
//Add xdelay
if (message.XDelay == null)
{
message.XDelay = new Delay();
message.XDelay.Stamp = DateTime.UtcNow;
}
messageBuffer.Add(message);
flush = BUFFER_SIZE <= messageBuffer.Count;
}
if (flush) FlushMessageBuffer();
}
}
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
if (!message.HasTo || message.To.IsServer)
{
context.Sender.SendTo(stream, XmppStanzaError.ToServiceUnavailable(message));
return;
}
var sessions = context.SessionManager.GetBareJidSessions(message.To);
if (0 < sessions.Count)
{
foreach(var s in sessions)
{
try
{
context.Sender.SendTo(s, message);
}
catch
{
context.Sender.SendToAndClose(s.Stream, message);
}
}
}
else
{
StoreOffline(message, context.StorageManager.OfflineStorage);
}
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
if (!message.HasTo || !message.To.HasResource) return;
string[] commands = message.To.Resource.Split('/');
if (commands.Length == 1 && commands[0] == ANNOUNCE)
{
Announce(stream, message, context);
}
else if (commands.Length == 2 && commands[1] == ONLINE)
{
AnnounceOnline(stream, message, context);
}
else if (commands.Length == 2 && commands[1] == ONLINEBROADCAST)
{
AnnounceOnlineBroadcast(stream, message, context);
}
else if (commands.Length == 2 && commands[1] == SERVICE)
{
AnnounceService(stream, message, context);
}
else
{
context.Sender.SendTo(stream, XmppStanzaError.ToServiceUnavailable(message));
}
}
public void SendMessage(string to, string subject, string text, int tenantId)
{
if (string.IsNullOrEmpty(to) || string.IsNullOrEmpty(text)) return;
var jid = GetJid(to, tenantId);
text = ModifyJabberNotification(text);
var message = new Message(
jid,
new Jid(GetTenantDomain(tenantId)),
MessageType.headline,
text,
subject) { XDelay = new Delay() { Stamp = DateTime.UtcNow } };
var session = xmppServer.SessionManager.GetSession(jid);
if (session != null)
{
var sender = (IXmppSender)xmppServer.GetService(typeof(IXmppSender));
sender.SendTo(session, message);
}
else
{
xmppServer.StorageManager.OfflineStorage.SaveOfflineMessages(message);
}
var archive = xmppServer.StorageManager.GetStorage<DbMessageArchive>("archive");
if (archive != null) archive.SaveMessages(message);
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
if (!message.HasTo || message.To.IsServer)
{
context.Sender.SendTo(stream, XmppStanzaError.ToServiceUnavailable(message));
return;
}
var session = context.SessionManager.GetSession(message.To);
if (session != null)
{
context.Sender.SendTo(session, message);
}
else
{
StoreOffline(message, context.StorageManager.OfflineStorage);
}
}
private void Announce(XmppStream stream, Message message, XmppHandlerContext context)
{
var userName = GetUser(message);
message.Body = string.Format("{0} announces {1}", userName, message.Body);
var offlineMessages = new List<Message>();
foreach (var user in context.UserManager.GetUsers(stream.Domain))
{
message.To = user.Jid;
var session = context.SessionManager.GetSession(message.To);
if (session != null)
{
context.Sender.SendTo(session, message);
}
else
{
offlineMessages.Add(message);
}
}
context.StorageManager.OfflineStorage.SaveOfflineMessages(offlineMessages.ToArray());
}
protected override XElement ProcessRequest(XmppServer server, Jid jid, NameValueCollection values)
{
var to = values["to"];
var subject = values["subject"];
var text = values["message"];
if (!string.IsNullOrEmpty(to) && !string.IsNullOrEmpty(text))
{
var jidTo = GetJid(to);
text = ModifyJabberNotification(text);
var message = new Message(
jidTo,
new Jid(CoreContext.TenantManager.GetCurrentTenant().TenantDomain),
MessageType.headline,
text,
subject ?? "") { XDelay = new Delay() { Stamp = DateTime.UtcNow } };
var session = server.SessionManager.GetSession(jid);
if (session != null)
{
var sender = (IXmppSender)server.GetService(typeof(IXmppSender));
sender.SendTo(session, message);
}
else
{
server.StorageManager.OfflineStorage.SaveOfflineMessages(message);
}
var archive = server.StorageManager.GetStorage<DbMessageArchive>("archive");
if (archive != null) archive.SaveMessages(message);
}
else
{
throw new ArgumentException("argument count mismatch");
}
return new XElement("ok");
}
public void ChangeSubject(MucRoomMember member, string subject)
{
if (RoomSettings.CanChangeSubject)
{
RoomSettings.Subject = subject;
Message msg = new Message();
msg.From = member.Jid;
msg.Type = MessageType.groupchat;
msg.Subject = subject;
Broadcast(member, true, msg);
}
else
{
Message msg = new Message();
msg.From = Jid;
msg.Type = MessageType.error;
msg.Error = new Error(ErrorCondition.NotAllowed);
member.Send(msg);
}
}
public void InviteUser(Message msg, User user, XmppStream stream)
{
if (RoomSettings.CanInvite)
{
Message inviteMsg = new Message(user.Invite.To, Jid, MessageType.normal, null);
User userElement = new User();
userElement.Invite = new Invite();
MucRoomMember member = GetRealMember(msg.From);
userElement.Invite.From = member == null ? msg.From : member.Jid;
userElement.Invite.Reason = user.Invite.Reason;
inviteMsg.RemoveAllChildNodes();
inviteMsg.AddChild(userElement);
if (!Send(inviteMsg))
{
// Return error
msg.SwitchDirection();
msg.Type = MessageType.error;
msg.Error = new Error(ErrorType.cancel, ErrorCondition.ItemNotFound);
Sender.SendTo(stream, msg);
}
}
else
{
msg.SwitchDirection();
msg.Type = MessageType.error;
msg.Error = new Error(ErrorType.cancel, ErrorCondition.NotAllowed);
Sender.SendTo(stream, msg);
}
}
public void DeclinedUser(Message msg, User user, XmppStream stream)
{
Message declineMsg = new Message(user.Decline.To, Jid, MessageType.normal, null);
User userElement = new User();
userElement.Decline = new Decline();
userElement.Decline.From = msg.From;
userElement.Decline.Reason = user.Decline.Reason;
declineMsg.RemoveAllChildNodes();
declineMsg.AddChild(userElement);
Send(declineMsg);
}
public void BroadcastMessage(Message msg, MucRoomMember member)
{
msg.From = member.Jid;
//store
if (RoomSettings.Logging)
{
mucService.MucStorage.AddMucMessages(Jid, msg);
}
Broadcast(member, true, msg);
}
private void MessageBroadcast(Message msg, MucRoomMember member)
{
Room.BroadcastMessage(msg, member);
}
private void HandleUserMessage(Message msg, User user, XmppStream stream)
{
if (user.Invite != null)
{
Room.InviteUser(msg, user,stream);
}
else if (user.Decline != null)
{
Room.DeclinedUser(msg, user,stream);
}
}
public override void HandleMessage(Streams.XmppStream stream, Message msg, XmppHandlerContext context)
{
User user = (User) msg.SelectSingleElement(typeof (User));
if (user != null)
{
HandleUserMessage(msg, user, stream);
}
else
{
//Groupchat message
MucRoomMember member = Room.GetRealMember(msg.From);
if (member != null && ReferenceEquals(member.Stream, stream) && member.Role != Role.none)
{
if (msg.Type == MessageType.groupchat)
{
if (msg.Subject!=null)
{
Room.ChangeSubject(member, msg.Subject);
}
else
{
MessageBroadcast(msg, member);
}
}
else
{
msg.SwitchDirection();
msg.Type = MessageType.error;
msg.Error = new Error(ErrorCondition.NotAcceptable);
context.Sender.SendTo(stream, msg);
}
}
else
{
msg.SwitchDirection();
msg.Type = MessageType.error;
msg.Error = new Error(ErrorCondition.Forbidden);
context.Sender.SendTo(stream, msg);
}
}
}
public override void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
HandleMulticastStanza(stream, message, context);
}
public void SendMessage(int tenantId, string from, string to, string text, string subject)
{
try
{
_log.DebugFormat("Send Message: tenantId={0}, from={1}, to={2}, text={3}", tenantId, from, to, text);
if (string.IsNullOrEmpty(text))
{
return;
}
if (from == null)
{
_reverseJabberServiceClient.SendMessage(string.Empty, to.ToLowerInvariant(), text, tenantId, string.Empty);
}
var jidFrom = GetJid(from, tenantId);
var jidTo = to != string.Empty ? GetJid(to, tenantId) : new Jid(jidFrom.Server);
var message = new Message(jidTo, jidFrom, MessageType.chat, text);
var sessions = _xmppServer.SessionManager.GetBareJidSessions(jidTo, GetSessionsType.All);
if (sessions.Count != 0)
{
foreach (var session in sessions)
{
if (session != null && !session.IsSignalRFake)
{
((IXmppSender)_xmppServer.GetService(typeof(IXmppSender))).SendTo(session, message);
}
}
}
else
{
_xmppServer.StorageManager.OfflineStorage.SaveOfflineMessages(message);
}
var handlers = _xmppServer.HandlerManager.HandlerStorage.GetStanzaHandlers(jidFrom, typeof(Message));
if (handlers.Count > 1)
{
var messageArchiveHandler = handlers[1] as MessageArchiveHandler;
if (messageArchiveHandler != null)
{
messageArchiveHandler.HandleMessage(null, message, null);
}
}
}
catch (Exception e)
{
_log.ErrorFormat("Unexpected error, from = {0}, to = {1}, {2}, {3}, {4}", from, to,
e.Message, e.StackTrace, e.InnerException != null ? e.InnerException.Message : string.Empty);
}
}
public static HistoryItem FromMessage(Message message)
{
message = (Message) message.Clone();
var item = new HistoryItem
{
From = message.From,
Body = message.Body,
Subject = message.Subject,
Thread = message.Thread,
Nickname = message.Nickname,
Type = message.Type,
Html = message.Html,
Headers = message.Headers,
XDelay = message.XDelay,
XEvent = message.XEvent
};
return item;
}
private void AnnounceOnline(XmppStream stream, Message message, XmppHandlerContext context)
{
foreach (var session in context.SessionManager.GetSessions().Where(x => x.Available))
{
message.To = session.Jid;
context.Sender.SendTo(session, message);
}
}
public virtual void HandleMessage(XmppStream stream, Message message, XmppHandlerContext context)
{
}
private void AnnounceOnlineBroadcast(XmppStream stream, Message message, XmppHandlerContext context)
{
string user = GetUser(message);
message.Body = string.Format("{0} says:\r\n{1}", user, message.Body);
AnnounceService(stream, message, context);
}
private string GetUser(Message message)
{
var nick = message.SelectSingleElement<Nickname>();
return nick != null ? nick.Value : message.From.User;
}
private void AnnounceService(XmppStream stream, Message message, XmppHandlerContext context)
{
message.From = new Jid(stream.Domain);
message.Nickname = null;
AnnounceOnline(stream, message, context);
}
