public static void PostMessage(this IWindow window, String message, String targetOrigin = "*", Object transfer = null)
{
var ev = new MessageEvent("message", false, false, message, targetOrigin);
var document = window.Document;
var loop = document.Context.GetService <IEventLoop>();
loop.EnqueueAsync(_ => window.Fire(ev));
}
public void BuildMessageEvent_WithRequiredFields()
{
IMessageEvent messageEvent = MessageEvent.Builder(MessageEventType.SENT, 1L).Build();
Assert.Equal(MessageEventType.SENT, messageEvent.Type);
Assert.Equal(1L, messageEvent.MessageId);
Assert.Equal(0L, messageEvent.UncompressedMessageSize);
}
private static void staticLogMessage(MessageEvent e)
{
lock (staticLockObj)
if (staticMessageLogHandler != null)
{
staticMessageLogHandler.BeginInvoke(dummy, e, null, null);
}
}
public void Run(Client client, MessageEvent msg)
{
string search = msg.ReadString();
List <MessengerSearch> friends = new List <MessengerSearch>();
List <MessengerSearch> notFriends = new List <MessengerSearch>();
Engine.Locator.MessengerController.MessengerSearch(search, client.Player, friends, notFriends);
client.SendComposer(new HabboSearchResultMessageComposer(friends, notFriends));
}
private void LogMessageString(bool sent, MessageEvent messageEvent)
{
if (Logger.IsDebugEnabled())
{
var verb = sent ? "Sent" : "Received";
var logString = $"Text {verb}: {messageEvent.Message}";
Logger.Debug(logString);
}
}
public static void TriggerEvent(string eventName, Message message)
{
MessageEvent thisEvent = null;
if (instance.eventDictionary.TryGetValue(eventName, out thisEvent))
{
thisEvent.Invoke(message);
}
}
/// <summary>
/// Checks if any <see cref="CommandAttribute">commands</see> are called in the message and invokes them.
/// </summary>
/// <param name="msgCreated">The supposed command message</param>
/// <param name="prefix">The current prefix used for the command</param>
/// <param name="config">The configuration of client's commands</param>
/// <returns>Any <see cref="CommandAttribute">command</see> has been invoked</returns>
public virtual async Task <bool> DoCommandsAsync(MessageEvent msgCreated, string prefix, CommandConfiguration config)
{
if (!msgCreated.Content !.StartsWith(prefix))
{
return(false);
}
string[] splitContent = msgCreated
.Content[prefix.Length..]
public void Run(Client client, MessageEvent msgEvent)
{
int roomId = msgEvent.ReadVL64();
if (client.CurrentRoom != null)
{
client.SendComposer(new RoomSettingsDataComposer(client.CurrentRoom));
}
}
void OnMessage(MessageEvent msg)
{
var evt = MessageReceived;
if (evt != null)
{
evt(this, msg.User, msg.Text);
}
}
public sealed override void Init(INetChannel channel, INode node)
{
base.Init(channel, node);
_fiber = new ServerFiber();
MessageEvent.Subscribe(OnClientMessage);
_handlersByNetContractId = new ConcurrentDictionary <uint, NetContractHandler>();
OnCreated();
}
private void OnSocketMessage(MessageEvent e)
{
//Console.WriteLine(e.Data != null ? e.Data.ToString() : "no reponse data");
dynamic obj = JSON.Parse(e.Data.ToString());
int msgId = (int)obj.msgId;
ReadMessage(msgId, obj);
}
private void SessionHelper_IncomingMessage(object sender, MessageEvent e)
{
if (e.Message is TextMessage)
{
TextMessage msg = (TextMessage)e.Message;
MessageBox.Show(msg.Text, msg.Caption);
}
}
public void Run(Client client, MessageEvent msgEvent)
{
if (client.CurrentRoomId < 1)
{
return;
}
client.CurrentRoom.SendComposer(new WaveMessageComposer(client.UserActor.VirtualId));
}
public void SendMessage(int number, string message)
{
if (MessageEvent != null)
{
MessageEvent.Invoke(this, new SmsEventArgs {
number = number, message = message
});
}
}
public void Run(Client client, MessageEvent msgEvent)
{
string subscriptionId = msgEvent.ReadString();
if (client.SubscriptionData.TryGetValue(subscriptionId, out SubscriptionData data))
{
client.SendComposer(new ScrSendUserInfoComposer(data));
}
}
public static void add_Message(Connection that, Action <MessageEvent> value)
{
if (!MessageFixup.ContainsKey(value))
{
MessageFixup[value] = i => value(MessageEvent.CloneFrom(i));
}
CommonExtensions.CombineDelegate(that, MessageFixup[value], MessageEvent.MESSAGE);
}
public void Run(Client client, MessageEvent msgEvent)
{
if (client.RoomCount == null)
{
client.RoomCount = Engine.Locator.RoomController.GetUserRoomCount(client.Player.Id);
}
client.SendComposer(new CanCreateRoomComposer(client.RoomCount > Engine.Locator.ConfigController.HHConfig.MaxRooms, Engine.Locator.ConfigController.HHConfig.MaxRooms));
}
/// <summary>
/// Event that fires when a plain text message is received from the broker.
/// This deserializes the message and hands it off to OnMessage.
/// </summary>
/// <param name="messageEvent">Text message event</param>
private async void OnTextMessage(MessageEvent messageEvent)
{
if (Logger.ToPrint.DoesPrint(LogLevel.Debug))
{
Logger.Debug("Text Received: " + messageEvent.Message);
}
await OnMessage(SerializationManager.Serializer.Deserialize(messageEvent.Message));
}
void statusCb(MessageEvent <gsa> statusArrayEvent)
{
ROS.Debug("actionlib", "Getting status over the wire.");
if (connectionMonitor != null)
{
connectionMonitor.processStatus(statusArrayEvent.getMessage(), statusArrayEvent.getPublisherName());
}
goalManager.updateStatuses(statusArrayEvent.getMessage());
}
private void LogMessageString(bool sent, MessageEvent messageEvent)
{
if (_logger.ToPrint.DoesPrint(LogLevel.Debug))
{
var verb = sent ? "Sent" : "Received";
var logString = $"Text {verb}: {messageEvent.Message}";
_logger.Debug(logString);
}
}
public void BuildMessageEvent_WithCompressedMessageSize()
{
IMessageEvent messageEvent =
MessageEvent.Builder(MessageEventType.SENT, 1L).SetCompressedMessageSize(123L).Build();
Assert.Equal(MessageEventType.SENT, messageEvent.Type);
Assert.Equal(1L, messageEvent.MessageId);
Assert.Equal(123L, messageEvent.CompressedMessageSize);
}
public static void TriggerEvent(MessageType type, string[] arg)
{
MessageEvent thisEvent = null;
if (instance._eventDictionary.TryGetValue(type, out thisEvent))
{
thisEvent.Invoke(arg);
}
}
private void SessionHelper_IncomingMessage(object sender, MessageEvent e)
{
if (e.Message is NotifyAreaMessage)
{
NotifyAreaMessage msg = (NotifyAreaMessage)e.Message;
UI.InvokeAction(() => notifyIcon.ShowBalloonTip(msg.Timeout, msg.Title, msg.Text, (ToolTipIcon)msg.Type));
}
}
public void Regist(int msgId, Type msgType, MessageEvent msgEvent)
{
if (_protocolDictionary.ContainsKey(msgId))
{
Log.Loggers.net.Debug(string.Format("Duplicate regist msgId {0}", msgId));
return;
}
_protocolDictionary.Add(msgId, new MessageHandler(msgType, msgEvent));
}
public void SendMessage(PhoneNumber phoneNumber, string message)
{
if (MessageEvent != null)
{
MessageEvent.Invoke(this, new SmsEventArgs {
Number = phoneNumber, Message = message
});
}
}
public void Register(Guid messageId, UnityAction <MessageEventArgs> callback)
{
if (!m_MessageListeners.TryGetValue(messageId, out var msgEvent))
{
msgEvent = new MessageEvent();
m_MessageListeners[messageId] = msgEvent;
}
msgEvent.AddListener(callback);
}
// 受信メッセージごとの分岐処理(現状テキストのみ)
protected override async Task OnMessageAsync(MessageEvent ev)
{
switch (ev.Message.Type)
{
case EventMessageType.Text:
await HandleTextAsync(ev.ReplyToken, ((TextEventMessage)ev.Message).Text, ev.Source.UserId);
break;
}
}
public bool Get(uint Id, out MessageEvent ev)
{
if (this.Messages.ContainsKey(Id))
{
ev = this.Messages[Id];
return true;
}
ev = null;
return false;
}
public Message Reply(string[] parameters, MessageEvent e)
{
try {
return(Reply(parameters[0]));
} catch (KeyNotFoundException) {
return(new Message(new ElementText("我还不会这句话emmmmm...")));
} catch {
return(new Message(new ElementText("干嘛?")));
}
}
public bool Get(uint Id, out MessageEvent ev)
{
if (this.Messages.ContainsKey(Id))
{
ev = this.Messages[Id];
return(true);
}
ev = null;
return(false);
}
public Message GetPlayerPP(string[] parameters, MessageEvent e)
{
// if (e.GetEndpoint () != (cqhttp.Cyan.Enums.MessageType.group_, 915383167))
// return new Message ("只能在XDOSU群里用");
var profile = parameters.Length > 0 ?
Profiles.Get(parameters[0]) :
Profiles.Get(e.sender.user_id);
return(new Message(profile != null ? profile.pp_raw : "not binded yet"));
}
static void MessageWriter( MessageEvent message )
{
if( message.Wait )
{
CUIMessage.Interact( message.Message );
}
else
{
Console.Write( message.Message );
}
}
public void Invoke(Sockets.Session Session, MessageEvent Message)
{
var Ticket = Message.Get<string>();
if (Session.SetTicket(Ticket))
{
Session.Write(new AuthenticationOKMessageComposer());
Session.Write(new HabboBroadcastMessageComposer("Trebuchet "
+ Framework.Get<AssemblyComponent>().ExecutingState + " "
+ Framework.Get<AssemblyComponent>().ExecutingVersion + Environment.NewLine + "Welcome, " + Session.Character.Username));
}
else
{
Session.Disconnect();
}
}
void client_MessageReceived(object sender, MessageEvent message)
{
switch (message.GetMessage.type)
{
case MessageType.SENDMESSAGE:
break;
case MessageType.PUBLISHMESSAGE:
{
string text;
PublishMessage msg = (PublishMessage)message.GetMessage;
if (msg.sender == client.UserName)
text = "You say: " + msg.message;
else
text = msg.sender + " says: " + msg.message;
AppendToRichEditControl(text);
}
break;
case MessageType.NEWUSERONLINE:
{
NewUserOnline msg = (NewUserOnline)message.GetMessage;
AppendToRichEditControl(msg.userName + " has logged on:-)");
}
break;
case MessageType.GETONLINEUSERS:
break;
case MessageType.USERLOGON:
{
UserLogOn msg = (UserLogOn)message.GetMessage;
AppendToRichEditControl("Welcome " + txtUserName.Text + "! You got the ID " + msg.id);
}
break;
case MessageType.NOMATCHINGTYPE:
break;
default:
break;
}
}
/// <summary>
/// Occurs when a message is received
/// </summary>
/// <param name="event"></param>
public void OnReceived(MessageEvent @event) {
this._eventAggregator.BeginPublishOnUIThread(@event);
}
/// <summary>
/// Safely logs a message.
/// </summary>
/// <param name="message"></param>
protected void logMessage(MessageEvent message)
{
if (messageLog != null)
messageLog(this, message);
}
private void MessageFutVM(MessageEvent e)
{
EventHandler<MessageEvent> Event = onMsgVMEvent;
if (Event != null)
Event(this, e);
}
/// <summary>
/// Occurs when a message is received
/// </summary>
/// <param name="event"></param>
public void OnReceived(MessageEvent @event) {
throw new System.NotImplementedException();
}
private void _Message(MessageEvent e)
{
EventHandler<MessageEvent> Event = onMsgEvent;
if (Event != null)
Event(this, e);
}
//Raise a MessageEvent (passes a message to the container, which should be logged)
protected virtual void TellManager(string message)
{
if (MessageSent != null)
{
MessageEvent e = new MessageEvent(message);
MessageSent(this, e);
}
}
void client_MessageReceived(object sender, MessageEvent messageEvent)
{
IComMessage msg = messageEvent.GetMessage;
switch (msg.type)
{
case MessageType.SENDMESSAGE:
{
SendMessage sendMessage = (SendMessage)msg;
PublishMessage pbMsg = new PublishMessage();
pbMsg.message = sendMessage.message;
pbMsg.sender = sendMessage.sender;
pbMsg.receiver = sendMessage.receiver;
MySQLDBHandler.SavePublisMsg(pbMsg);
BroadcastMsg(pbMsg);
}
break;
case MessageType.GETONLINEUSERS:
{
GetOnlineUsers gou = (GetOnlineUsers)msg;
gou.userList = new List<string>();
foreach (Client item in m_workerSocketList)
{
gou.userList.Add(item.ClientInfo.Name);
}
SendMsgToClient(gou, messageEvent.ClientID);
}
break;
case MessageType.USERLOGON:
{
messageEvent.ClientID.Name = ((UserLogOn)msg).userName;
UserLogOn returnMsg = (UserLogOn)msg;
returnMsg.id = messageEvent.ClientID.ID;
returnMsg.success = true;
returnMsg.errorMessage = "";
SendMsgToClient(returnMsg, messageEvent.ClientID);
NewUserOnline nuo = new NewUserOnline();
nuo.userName = messageEvent.ClientID.Name;
BroadCastExceptSender(nuo, messageEvent.ClientID);
}
break;
case MessageType.GETNEWMESSAGES:
{
GetNewMessages getNewMessages = (GetNewMessages)msg;
List<PublishMessage> messages = MySQLDBHandler.GetStoredMessages(getNewMessages.lastSeenTimeStamp);
foreach (var item in messages)
{
SendMsgToClient(item, messageEvent.ClientID);
}
}
break;
case MessageType.NOMATCHINGTYPE:
break;
default:
break;
}
if (clientReceivedMessageEvent != null)
clientReceivedMessageEvent(this, messageEvent);
}
public void Invoke(Sockets.Session Session, MessageEvent Message)
{
Session.Write(new SessionParamsMessageComposer());
}
/// <summary>
/// Posts the message event.
/// </summary>
/// <param name="event_Renamed">The event_ renamed.</param>
public virtual void postMessageEvent(MessageEvent event_Renamed)
{
messageQueue.Add(event_Renamed);
}
/// <summary>
/// Occurs when a message is received
/// </summary>
/// <param name="event"></param>
public void OnReceived(MessageEvent @event) {
Debug.WriteLine("Received: {0}", @event.Message == null ? @event.Exception.GetType().FullName : @event.Message.GetType().FullName, "");
this._receivedMessageEvents.Enqueue(@event);
}
/// <summary>
/// Occurs before a message is send
/// </summary>
/// <param name="event"></param>
public void OnSending(MessageEvent @event) {
Debug.WriteLine("Send: {0}", @event.Message == null ? @event.Exception.GetType().FullName : @event.Message.GetType().FullName, "");
this._sentMessageEvents.Enqueue(@event);
}
public LogMessageEvent(LogPanel enclosingInstance, MessageEvent event_Renamed)
: this(enclosingInstance, event_Renamed.Type, event_Renamed.Message, event_Renamed.ChannelId)
{
InitBlock(enclosingInstance);
}
/// <summary>
/// Occurs before a message is send
/// </summary>
/// <param name="event"></param>
public void OnSending(MessageEvent @event) {
// we are currently not interested in these
}
public void Invoke(Sockets.Session Session, MessageEvent Message)
{
Session.Write(new HabboActivityPointNotificationMessageComposer(Session.Character.ActivityPoints));
Session.Write(new UserRightsMessageComposer(2)); // MEMBERSHIP > RIGHTS
Session.Write(new NavigatorSettingsComposer(0)); // NAVIGATOR > STARTROOM
}
protected static void logMessage(MessageEvent message)
{
if (messageLog != null)
messageLog(dummy, message);
}
public void Invoke(Sockets.Session Session, MessageEvent Message)
{
Session.Write(new CreditBalanceComposer(Session.Character.Credits));
}
/// <summary>
/// Occurs before a message is send
/// </summary>
/// <param name="event"></param>
public void OnSending(MessageEvent @event) {
throw new System.NotImplementedException();
}
private static void staticLogMessage(MessageEvent e)
{
lock (staticLockObj)
if (staticMessageLogHandler != null)
staticMessageLogHandler.BeginInvoke(dummy, e, null, null);
}
