public void PostMessageToPrivateDiscussion(Message message, PrivateDiscussion PrivateDiscussion)
{
using (var request = new Messaging.PrivateDiscussion.Message.Base(PrivateDiscussion.ThreadId)
{
DefaultHeaders = new WebHeaderCollection()
{
{ HttpRequestHeader.Accept, "application/json" },
{ HttpRequestHeader.ContentType, "application/json" },
{ HttpRequestHeader.Authorization, "Token " + Auth.Token }
}
}.POST(Parser.EntitytoJSON(message, message.GetType()))) { }
}
public void PostPrivateDiscussion(PrivateDiscussion privatediscussion)
{
using (var request = new Messaging.Channel.Base()
{
DefaultHeaders = new WebHeaderCollection()
{
{ HttpRequestHeader.Accept, "application/json" },
{ HttpRequestHeader.ContentType, "application/json" },
{ HttpRequestHeader.Authorization, "Token " + Auth.Token }
}
}.POST(Parser.EntitytoJSON(privatediscussion, typeof(PrivateDiscussion)))) { }
}
/// <summary>
/// Triggers when the user clicks on the "Create !" button.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CreateChannel_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(this.textBox1.Text) || string.IsNullOrEmpty(this.textBox1.Text))
{
this.textBox1.BackColor = Constants.RED;
System.Threading.Thread t = new System.Threading.Thread(() => {
System.Threading.Thread.Sleep(3000);
this.textBox1.Invoke(new Action(() => {
this.BackColor = Color.White;
}));
});
t.Start();
return;
}
List <int> checkedNodes = new List <int>();
checkedNodes.Add((int)Form1.Instance.user?.UserId);
foreach (object t in this.listBox1.SelectedItems)
{
checkedNodes.Add((int)((User)((listItem)t).o).UserId);
}
switch (this.comboBox1.SelectedIndex)
{
case 0:
PrivateDiscussion d = new PrivateDiscussion();
d.Type = PrivateDiscussion.Types.private_channel;
d.Title = this.textBox1.Text;
d.Description = this.textBox2.Text;
d.Members = checkedNodes.ToArray();
Form1.Instance.session.REST.PostPrivateDiscussion(d);
break;
case 1:
Channel c = new Channel();
c.Title = this.textBox1.Text;
c.Members = checkedNodes.ToArray();
c.Type = Channel.Types.public_channel;
c.Description = this.textBox2.Text;
Form1.Instance.session.REST.PostChannel(c);
break;
}
MessageBox.Show("Discussion created successfully.");
this.Close();
}
public static dynamic EntitytoJSON(dynamic entity, Type type)
{
if (type == typeof(Channel))
{
Channel channel = (Channel)entity;
return(new {
id = channel.ThreadId,
slug = channel.Slug,
title = channel.Title,
type = EnumToString(channel.Type, typeof(Channel.Types)),
description = channel.Description,
membership = EntitytoJSON(channel.Membership, typeof(Membership)),
memberships = EntitytoJSON(channel.Memberships ?? new Membership[] { }, typeof(Membership[])),
manager_user = channel.ManagerUser,
manager_details = EntitytoJSON(channel.ManagerDetails, typeof(User)),
members = channel.Members
});
}
else if (type == typeof(Channel[]))
{
List <dynamic> channels = new List <dynamic>();
foreach (var channel in (entity as Channel[]))
{
channels.Add(EntitytoJSON(channel, typeof(Channel)));
}
return(channels.ToArray());
}
else if (type == typeof(FriendRequest))
{
FriendRequest friendrequest = (FriendRequest)entity;
return(new {
requester = friendrequest.Requester,
addresser = friendrequest.Addresser,
friend_detail = EntitytoJSON(friendrequest.FriendDetails, typeof(User)),
request_date = friendrequest.RequestDate.ToUniversalTime(),
approval_date = friendrequest.ApprovalDate.ToUniversalTime(),
friendship_end_date = friendrequest.FriendshipEndDate.ToUniversalTime(),
active = friendrequest.Active
});
}
else if (type == typeof(FriendRequest[]))
{
List <dynamic> friendrequests = new List <dynamic>();
foreach (var friendrequest in (entity as FriendRequest[]))
{
friendrequests.Add(EntitytoJSON(friendrequest, typeof(FriendRequest)));
}
return(friendrequests);
}
else if (type == typeof(Entities.Friendship))
{
Entities.Friendship friendship = (Entities.Friendship)entity;
return(new {
id = friendship.FriendshipId,
requester_user = friendship.Requester,
addresser_user = friendship.Addresser,
request_date = friendship.RequestDate.ToUniversalTime(),
approval_date = friendship.ApprovalDate.ToUniversalTime(),
friendship_end_date = friendship.FriendshipEndDate.ToUniversalTime(),
active = friendship.Active
});
}
else if (type == typeof(Entities.Friendship[]))
{
List <dynamic> friendships = new List <dynamic>();
foreach (var friendship in (entity as Entities.Friendship[]))
{
friendships.Add(EntitytoJSON(friendship, typeof(Entities.Friendship)));
}
return(friendships.ToArray());
}
else if (type == typeof(Membership))
{
Membership membership = (Membership)entity;
return(new {
id = membership.MembershipId,
thread = membership.ThreadId,
user = membership.UserId,
last_seen_date = membership.LastSeenDate.ToUniversalTime(),
last_seen_message = membership.LastSeenMessageId,
active = membership.IsParticipant,
join_date = membership.JoinDate.ToUniversalTime(),
user_details = EntitytoJSON(membership.UserDetails, typeof(User)),
unchecked_count = membership.UncheckedCount
});
}
else if (type == typeof(Membership[]))
{
List <dynamic> memberships = new List <dynamic>();
foreach (var membership in (entity as Membership[]))
{
memberships.Add(EntitytoJSON(membership, typeof(Membership)));
}
return(memberships.ToArray());
}
else if (type == typeof(Message))
{
Message message = (Message)entity;
return(new {
id = message.MessageId,
thread = message.ThreadId,
user_sender = message.UserId,
contents = message.Contents,
sent_date = message.SentDate.ToUniversalTime(),
type = EnumToString(message.Type, typeof(Message.Types)),
tags = EntitytoJSON(message.Tags ?? new MessageTag[] { }, typeof(MessageTag[]))
});
}
else if (type == typeof(Message[]))
{
List <dynamic> messages = new List <dynamic>();
foreach (var message in (entity as Message[]))
{
messages.Add(JSONtoEntity(message, typeof(Message)));
}
return(messages.ToArray());
}
else if (type == typeof(MessageTag))
{
MessageTag tag = (MessageTag)entity;
return(new {
tagger_user = tag.TaggedUserId,
message = tag.MessageId,
placeholder_position = tag.PlaceholderPosition,
tagged_user_details = EntitytoJSON(tag.TaggedUserDetails, typeof(User))
});
}
else if (type == typeof(MessageTag[]))
{
List <dynamic> messagetags = new List <dynamic>();
foreach (var messagetag in (entity as MessageTag[]))
{
messagetags.Add(JSONtoEntity(messagetag, typeof(MessageTag)));
}
return(messagetags.ToArray());
}
else if (type == typeof(PrivateDiscussion))
{
PrivateDiscussion privatediscussion = (PrivateDiscussion)entity;
return(new {
id = privatediscussion.ThreadId,
slug = privatediscussion.Slug,
title = privatediscussion.Title,
type = EnumToString(privatediscussion.Type, typeof(PrivateDiscussion.Types)),
description = privatediscussion.Description,
creator_user = privatediscussion.CreatorUser,
manager_user = privatediscussion.ManagerUser,
manager_details = EntitytoJSON(privatediscussion.ManagerDetails, typeof(User)),
membership = EntitytoJSON(privatediscussion.Membership, typeof(Membership)),
memberships = EntitytoJSON(privatediscussion.Memberships, typeof(Membership[])),
interlocutor_membership = EntitytoJSON(privatediscussion.InterlocutorMembership, typeof(Membership))
});
}
else if (type == typeof(PrivateDiscussion[]))
{
List <dynamic> privatediscussions = new List <dynamic>();
foreach (var privatediscussion in (entity as PrivateDiscussion[]))
{
privatediscussions.Add(EntitytoJSON(privatediscussion, typeof(PrivateDiscussion)));
}
return(privatediscussions.ToArray());
}
else if (type == typeof(Thread))
{
Thread thread = (Thread)entity;
return(new {
id = thread.ThreadId,
slug = thread.Slug,
title = thread.Title,
type = EnumToString(thread.Type, typeof(Thread.Types)),
description = thread.Description,
creator_user = thread.CreatorUser,
manager_user = thread.ManagerUser,
manager_details = EntitytoJSON(thread.ManagerDetails, typeof(User)),
membership = EntitytoJSON(thread.Membership, typeof(Membership)),
memberships = EntitytoJSON(thread.Memberships, typeof(Membership[]))
});
}
else if (type == typeof(Thread[]))
{
List <dynamic> threads = new List <dynamic>();
foreach (var thread in (entity as Thread[]))
{
threads.Add(EntitytoJSON(thread, typeof(PrivateDiscussion)));
}
return(threads.ToArray());
}
else if (type == typeof(User))
{
User user = (User)entity;
return(new {
id = user.UserId,
username = user.Username,
first_name = user.FirstName,
last_name = user.LastName,
type = EnumToString(user.Type, typeof(User.Types)),
});
}
else if (type == typeof(User[]))
{
List <dynamic> users = new List <dynamic>();
foreach (var user in (entity as User[]))
{
users.Add(EntitytoJSON(user, typeof(User)));
}
return(users.ToArray());
}
else
{
throw new Exception("Unhandled Type " + type.ToString());
}
}
/// <summary>
/// Évènement déclenché lors de la réception de données du serveur
/// </summary>
/// <param name="data">Données venant du serveur</param>
private void Conn_OnReceive(string data)
{
string command = data.Split(':')[0];
dynamic json = JSON.Parse(data.Substring(data.IndexOf(':') + 1));
Console.WriteLine(data);
switch ((string)json.type.ToString())
{
case "authenticate":
if (json.success == true)
{
Send("!subscribe:messaging,users." + session.GetProfile().UserId);
foreach (var c in session.GetAllChannels())
{
Send("!subscribe:messaging,threads." + c.ThreadId);
subscriptions.Add(c.ThreadId, c);
}
foreach (var p in session.GetAllPrivateDiscussions())
{
Send("!subscribe:messaging,threads." + p.ThreadId);
subscriptions.Add(p.ThreadId, p);
}
Console.WriteLine("Authenticated !");
}
else
{
Console.WriteLine("Oops.. check your credentitals..");
}
break;
case "subscribe":
if (json.success == true)
{
Console.WriteLine("Subscribed to " + json.payload.channel);
}
else
{
Console.WriteLine("Unable to subscribe to " + json.payload.channel);
subscriptions.Remove(Convert.ToInt32(((string)json.payload.channel).Split('.')[1]));
}
break;
case "discussion_change":
PrivateDiscussion discussion = Parser.JSONtoEntity(json.payload, typeof(PrivateDiscussion));
if (!subscriptions.ContainsKey(discussion.ThreadId))
{
subscriptions.Add(discussion.ThreadId, discussion);
Send("!subscribe:messaging,threads." + discussion.ThreadId);
}
OnDiscussionChange?.Invoke(Parser.JSONtoEntity(json.payload, typeof(PrivateDiscussion)));
break;
case "channel_change":
Channel channel = Parser.JSONtoEntity(json.payload, typeof(Channel));
if (!subscriptions.ContainsKey(channel.ThreadId))
{
subscriptions.Add(channel.ThreadId, channel);
Send("!subscribe:messaging,threads." + channel.ThreadId);
}
OnChannelChange?.Invoke(channel);
break;
case "new_friend_request":
OnNewFriendshipRequest?.Invoke(Parser.JSONtoEntity(json.payload, typeof(FriendRequest)));
break;
case "friendship_addressed":
OnFriendshipAdressed?.Invoke(Parser.JSONtoEntity(json.payload, typeof(Friendship)));
break;
case "message":
OnMessageReceived?.Invoke(Parser.JSONtoEntity(json.payload, typeof(Message)));
break;
default:
Console.WriteLine("Unhandled event " + json.type);
break;
}
}
