/// <summary>
/// Create the normal beacon message
/// </summary>
/// <returns></returns>
protected Message InstructorMakeBeaconMessage()
{
using (Synchronizer.Lock(this.m_Model.Participant.SyncRoot)) {
using (Synchronizer.Lock(this.m_Model.Participant.Role.SyncRoot)) {
Message role = RoleMessage.ForRole(this.m_Model.Participant.Role);
InstructorModel instructor = ((InstructorModel)this.m_Model.Participant.Role);
if (instructor.CurrentPresentation != null)
{
role.InsertChild(new InstructorCurrentPresentationChangedMessage(instructor.CurrentPresentation));
}
if (instructor.CurrentDeckTraversal != null)
{
using (Synchronizer.Lock(instructor.CurrentDeckTraversal.SyncRoot)) {
Message traversal = new InstructorCurrentDeckTraversalChangedMessage(instructor.CurrentDeckTraversal);
Message predecessor = traversal.Predecessor;
traversal.Predecessor = new SlideInformationMessage(instructor.CurrentDeckTraversal.Current.Slide);
traversal.Predecessor.InsertChild(new TableOfContentsEntryMessage(instructor.CurrentDeckTraversal.Current));
traversal.Predecessor.AddOldestPredecessor(predecessor);
role.InsertChild(traversal);
}
}
return(role);
}
}
}
public HttpResponseMessage Post(TokenDTO token)
{
HttpResponseMessage responseMessage;
bool valid;
if (token.Token == null)
{
valid = false;
}
else
{
valid = auth.VerifyTokenDate(token.Token);
// valid = true;
}
if (!valid)
{
// Token invalid
var json = new JSendMessage("fail", "Invalid Authorization Key");
responseMessage = Request.CreateResponse(HttpStatusCode.Forbidden, json);
}
else
{
string role = tokens.GetRoleByToken(token.Token);
// string role = "admin";
var json = new RoleMessage(role);
responseMessage = Request.CreateResponse(HttpStatusCode.OK, json);
}
return(responseMessage);
}
public async Task RemoveRoleReactionAsync(DiscordMessage message, DiscordEmoji emoji)
{
RoleMessage tracked = await GetTrackedMessageAsync(message) ?? throw new ArgumentException("Message is not tracked.", nameof(message));
tracked.Roles.Remove(emoji.Name);
await _roleMessages.ReplaceOneAsync(Builders <RoleMessage> .Filter.Eq(m => m.Id, tracked.Id), tracked);
}
public void UpdateRole(int role)
{
if (IsConnected())
{
// update local player.
players[serverAssignedId].SetRole(role);
var roleMessage = new RoleMessage();
roleMessage.role = role;
client.Send(CustomNetMsg.Role, roleMessage);
}
}
public async Task InitReactionsAsync(CommandContext context, DiscordMessage message)
{
RoleMessage tracked = await _service.GetTrackedMessageAsync(message);
foreach (string reaction in tracked.Roles.Keys)
{
if (!DiscordEmoji.TryFromUnicode(context.Client, reaction, out DiscordEmoji emoji))
{
DiscordEmoji.TryFromName(context.Client, $":{reaction}:", out emoji);
}
await message.CreateReactionAsync(emoji);
}
await message.RespondAsync("Reactions initialized.");
}
public MyMessage Get()
{
AuthModel authModel = new AuthModel();
var header = Request.Headers.SingleOrDefault(x => x.Key == "token");
bool isAdmin = authModel.VerifyAdminToken(header.Value.First());
RoleMessage msg;
if (isAdmin)
{
msg = new RoleMessage("admin");
return(msg);
}
else
{
msg = new RoleMessage("user");
return(msg);
}
}
void GotRole(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <RoleMessage>();
players[netMsg.conn.connectionId].SetRole(msg.role);
if (lobbyGui != null)
{
lobbyGui.UpdateUI(players);
}
// broadcast
var roleMessage = new RoleMessage();
roleMessage.id = netMsg.conn.connectionId;
roleMessage.role = msg.role;
NetworkServer.SendToAll(CustomNetMsg.Role, roleMessage);
}
/// <summary>
/// If current role is public, then resend RoleMessage and GroupMessage for reconnection
/// </summary>
private void SendRoleAndGroupMessage(TCPMessageSender sender)
{
using (Synchronizer.Lock(this.m_Model.Participant.SyncRoot)) {
if (this.m_Model.Participant.Role is PublicModel)
{
//Send RoleMessage
UW.ClassroomPresenter.Network.Messages.Message message = RoleMessage.ForRole(this.m_Model.Participant.Role);
message.Group = Group.AllParticipant;
sender.Send(message);
//Send GroupMessage
foreach (Group group in this.m_Model.Participant.Groups)
{
message = new ParticipantGroupAddedMessage(group);
message.Group = Group.AllParticipant;
sender.Send(message);
}
}
}
}
/// <summary>
/// Even though we are not an instructor, here we fake an instructor beacon message for the purpose of unicast to multicast
/// bridging.
/// </summary>
/// <returns></returns>
protected Message NonInstructorMakeBeaconMessage()
{
InstructorModel instructor = new InstructorModel(m_NonInstructorId);
Message role = RoleMessage.ForRole(instructor);
using (Synchronizer.Lock(this.m_Model.Workspace)) {
if (this.m_Model.Workspace.CurrentPresentation != null)
{
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentPresentation.SyncRoot)) {
if (this.m_Model.Workspace.CurrentPresentation.Value != null)
{
role.InsertChild(new InstructorCurrentPresentationChangedMessage(this.m_Model.Workspace.CurrentPresentation));
}
}
}
if (this.m_Model.Workspace.CurrentDeckTraversal != null)
{
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) {
if (this.m_Model.Workspace.CurrentDeckTraversal.Value != null)
{
Message traversal = new InstructorCurrentDeckTraversalChangedMessage(this.m_Model.Workspace.CurrentDeckTraversal.Value, false);
Message predecessor = traversal.Predecessor;
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) {
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).Current.SyncRoot)) {
traversal.Predecessor = new SlideInformationMessage((~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide);
TableOfContentsModel.Entry entry = (~this.m_Model.Workspace.CurrentDeckTraversal).Current;
if (entry != null)
{
traversal.Predecessor.InsertChild(new TableOfContentsEntryMessage(entry));
}
traversal.Predecessor.AddOldestPredecessor(predecessor);
role.InsertChild(traversal);
}
}
}
}
}
}
return(role);
}
public async Task TrackNewRoleReactionAsync(DiscordMessage message, DiscordEmoji emoji, DiscordRole role)
{
RoleMessage tracked = await GetTrackedMessageAsync(message);
if (tracked is null)
{
tracked = new(message);
await _roleMessages.InsertOneAsync(tracked);
}
if (tracked.Roles.Count >= RoleMessage.MaxReactionsPerMessage)
{
throw new ArgumentOutOfRangeException(nameof(message), "Cannot track more reactions for this message.");
}
if (tracked.Roles.ContainsKey(emoji.Name))
{
throw new ArgumentException("This Emoji is already used for another role.", nameof(emoji));
}
tracked.Roles.Add(emoji.Name, role.Id);
await _roleMessages.ReplaceOneAsync(Builders <RoleMessage> .Filter.Eq(m => m.Id, tracked.Id), tracked);
}
public async Task <ulong> GetTrackedRoleIdAsync(DiscordMessage message, DiscordEmoji emoji)
{
RoleMessage tracked = await GetTrackedMessageAsync(message);
return(tracked?.Roles.GetValueOrDefault <string, ulong>(emoji.Name, 0) ?? 0);
}
