/// <summary>
/// Allows occupants to request privileges to a room.
/// </summary>
public void RequestPrivilige(Jid room, Role role)
{
if (role == Role.None)
{
return;
}
XmlElement formTypeValue = Xml.Element("value")
.Text(MucNs.NsRequest);
XmlElement formType = Xml.Element("field")
.Attr("var", "FORM_TYPE")
.Child(formTypeValue);
XmlElement requestedRoleValue = Xml.Element("value")
.Text(role.ToString().ToLowerInvariant());
XmlElement requestedRole = Xml.Element("field")
.Attr("var", MucNs.Role)
.Attr("type", "list-single")
.Attr("label", "Requested Role")
.Child(requestedRoleValue);
DataField[] fields =
{
new DataField(formType),
new DataField(requestedRole)
};
SubmitForm form = new SubmitForm(fields);
var message = new Core.Message(room, im.Jid, form.ToXmlElement());
SendMessage(message);
}
/// <summary>
/// Initializes a new instance of the Message class from the specified
/// instance.
/// </summary>
/// <param name="message">An instance of the Core.Message class to
/// initialize this instance with.</param>
/// <exception cref="ArgumentNullException">The message parameter is null.</exception>
/// <exception cref="ArgumentException">The 'type' attribute of
/// the specified message stanza is invalid.</exception>
internal Message(Core.Message message)
{
message.ThrowIfNull("message");
type = ParseType(message.Data.GetAttribute("type"));
element = message.Data;
AlternateSubjects = new XmlDictionary(element, "subject", "xml:lang");
AlternateBodies = new XmlDictionary(element, "body", "xml:lang");
}
protected override void OnReceived(Core.Message message)
{
if (Control.InvokeRequired)
{
Control.BeginInvoke(_handler, message);
}
else
{
base.OnReceived(message);
}
}
public override void HandleMessage(Core.Message message)
{
string str = null;
if (message.Is <string>(Messages.ToolSelected, ref str))
{
SelectedTool = (str == this.Name);
message.Handle();
}
base.HandleMessage(message);
}
public async Task CreatedConversationMessage(string user, string conversationId, string message)
{
var messageDetails = new Core.Message()
{
Author = await users.RetrieveById(user),
CreatedAt = DateTime.Now,
Text = message,
Channel = conversationId
};
await Clients.Group(conversationId).SendAsync("newConversationMessage", messageDetails);
var createdMessageId = await conversationMessages.Create(messageDetails);
}
public async Task CreatedMessage(string user, string channelId, string message)
{
var messageDetails = new Core.Message()
{
Author = await users.RetrieveById(user),
CreatedAt = DateTime.Now,
Text = message
};
await Clients.Group(channelId).SendAsync("newMessage", messageDetails);
var createdMessageId = await messages.Create(messageDetails);
await channels.AddMessage(channelId, user, createdMessageId);
}
private void PrintMessage(Core.Message message)
{
if (chatBox.Text.Length > 0 && !chatBox.Text.EndsWith("\n"))
{
chatBox.AppendText(Environment.NewLine);
}
int offset = chatBox.TextLength;
chatBox.AppendText(message.Sender + ":");
chatBox.Select(offset, chatBox.TextLength - offset);
chatBox.SelectionColor = Color.Blue;
offset = chatBox.TextLength;
chatBox.AppendText(" " + message.Text);
chatBox.Select(offset, chatBox.TextLength - offset);
chatBox.SelectionColor = Color.Black;
chatBox.Select(chatBox.TextLength, 0);
chatBox.ScrollToCaret();
}
public void MessageToStream()
{
var message = new Core.Message();
message.Address = "foo";
message.Init("MrBoolean", true);
message.Init("MrDouble", Math.PI);
message.Init("MsString", "lorem");
message["MsString"].Add("ipsum");
message["Empty"] = Bin.New(typeof (bool));
var stream = message.Serialize();
var newMessage = stream.DeSerializeMessage();
Assert.AreEqual(message["MrBoolean"].ToString(), newMessage["MrBoolean"].ToString());
Assert.AreEqual(message["MsString"].ToString(), newMessage["MsString"].ToString());
Assert.AreEqual(0, newMessage["Empty"].Count);
}
public override void Evaluate(int SpreadMax)
{
SpreadMax = 0;
if (!FSet[0])
{
//if (FInput.IsChanged)
//{
//}
FOutput.SliceCount = 0;
FOutput.Flush();
return;
}
foreach (string name in FPins.Keys)
{
var pin = ToISpread(FPins[name]);
pin.Sync();
SpreadMax = Math.Max(pin.SliceCount, SpreadMax);
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
Core.Message message = new Core.Message();
message.Address = FAddress[i];
foreach (string name in FPins.Keys)
{
message.AssignFrom(name, (IEnumerable)ToISpread(FPins[name])[i]);
}
FOutput[i] = message;
// FLogger.Log(LogType.Debug, "== Message "+i+" == \n" + message.ToString());
// foreach (string name in message.GetDynamicMemberNames()) FLogger.Log(LogType.Debug, message[name].GetType()+" "+ name);
}
FOutput.Flush();
}
public override void HandleMessage(Core.Message message)
{
base.HandleMessage(message);
switch (message.Type)
{
case Messages.CameraSetZoom:
this.startzoom = this.Camera.Zoom;
if (message.Data is float)
{
this.Camera.TargetZoom = (float)message.Data;
}
else if (message.Data is int)
{
this.Camera.TargetZoom = (int)message.Data;
}
else
{
this.Camera.TargetZoom = 1;
}
this.transition = 1;
break;
}
}
internal InviteDeclined(Core.Message message)
: base(message.Data)
{
}
internal Invite(Core.Message message)
: base(message.Data)
{
}
internal static bool IsElement(Core.Message message)
{
Invite temp = new Invite(message);
return(temp?.XElement?.NamespaceURI == MucNs.NsUser && temp?.InviteElement != null);
}
/// <summary>
/// Initializes a new instance of the Message class from the specified
/// instance.
/// </summary>
/// <param name="message">An instance of the Core.Message class to
/// initialize this instance with.</param>
/// <exception cref="ArgumentNullException">The message parameter is null.</exception>
/// <exception cref="ArgumentException">The 'type' attribute of
/// the specified message stanza is invalid.</exception>
internal Message(Core.Message message)
: this(message.Data, DelayedDelivery.GetDelayedTimestampOrNow(message.Data))
{
}
internal DirectMucInvite(Core.Message message)
: base(message.Data)
{
}
internal static bool IsElement(Core.Message message)
{
DirectMucInvite temp = new DirectMucInvite(message);
return(temp?.XElement?.NamespaceURI == conference && temp?.InviteElement != null);
}
internal static bool IsElement(Core.Message message)
{
DirectInvite temp = new DirectInvite(message);
return(temp?.Data["x"]?.NamespaceURI == "jabber:x:conference");
}
public bool Input(Im.Message stanza)
{
if (MucError.IsError(stanza))
{
// Unable to send a message... many reasons
var error = new MucError(stanza);
MucErrorResponse?.Raise(this, new GroupErrorEventArgs(error));
return(true);
}
if (Invite.IsElement(stanza))
{
// Incoming chat room invite
var invite = new Invite(stanza);
InviteReceived.Raise(this, new GroupInviteEventArgs(invite));
return(true);
}
if (DirectInvite.IsElement(stanza))
{
// Incoming chat room invite
var invite = new DirectInvite(stanza);
InviteReceived.Raise(this, new GroupInviteEventArgs(invite));
return(true);
}
if (InviteDeclined.IsElement(stanza))
{
// Chat room invite was declined
var invite = new InviteDeclined(stanza);
InviteWasDeclined.Raise(this, new GroupInviteDeclinedEventArgs(invite));
return(true);
}
if (stanza.Subject != null)
{
// Subject change
SubjectChanged.Raise(this, new Im.MessageEventArgs(stanza.From, stanza));
return(true);
}
// Things that could happen here:
// Receive Registration Request
// Receive Voice Request
XmlElement xElement = stanza.Data["x"];
if (xElement != null && xElement.NamespaceURI == MucNs.NsXData)
{
switch (xElement.FirstChild.Value)
{
default:
break;
case MucNs.NsRequest:
// Invoke Voice Request Submission callback/event.
// 8.6 Approving Voice Requests
if (VoiceRequested != null)
{
SubmitForm form = VoiceRequested.Invoke(new RequestForm(xElement));
var message = new Core.Message(stanza.From, im.Jid, form.ToXmlElement());
SendMessage(message);
return(true);
}
break;
case MucNs.NsRegister:
// Invoke Registration Request Submission callback/event.
// 9.9 Approving Registration Requests
// I'm unsure on how to implement this.
// return true;
break;
}
}
// Any message with a body can be managed by the IM extension
// Such as Group Chat Message & Group Chat History
return(false);
}
void OnSendMessage(object obj)
{
if (Message == null) Message = new Core.Message(Provider.Id, new List<string>() { Observer.Id }, "some_message");
Provider.Send(Message);
}
private void SendMessage(Core.Message message)
{
im.SendMessage(new Im.Message(message));
}
public void Broadcast(Core.Message message)
{
var broadcastMessage = new Core.Message(message.From, null, message.Content);
_messageServer.SendMessage(broadcastMessage);
}
