public Task <JavaScriptExecutionResult> ExecuteFunctionAsync(CefFrame frame, JavaScriptValue[] arguments = null)
{
CheckIsRendererFunction();
var tsc = new TaskCompletionSource <JavaScriptExecutionResult>();
if (JavaScriptObjectRepository.JavaScriptExecutionTasks.TryAdd(new Tuple <int, long>(tsc.GetHashCode(), frame.Identifier), tsc))
{
var jsvalue = arguments == null?JavaScriptValue.CreateArray() : arguments.ToJSValue();
var message = BridgeMessage.Create(JavaScriptCommunicationBridge.EVALUATE_JS_CALLBACK);
message.Arguments.Add(MessageValue.CreateInt(tsc.GetHashCode()));
message.Arguments.Add(MessageValue.CreateInt(JSFunctionDescriber.Id));
message.Arguments.Add(MessageValue.CreateString(jsvalue.ToDefinition()));
JavaScriptCommunicationBridge.SendProcessMessage(CefProcessId.Renderer, frame, message);
return(tsc.Task);
}
throw new InvalidOperationException("Same function already exists.");
}
// This controller only expects messages from clients; the Discord bridge posts to
// DiscordMessageController.cs
/// <summary>
/// Sends a message from the web chat to Discord and notifies other clients to stop the typing indicator.
/// </summary>
/// <param name="message">The SendMessage object representing the current operation.</param>
/// <returns>A Task representing the state of the request.</returns>
public async Task SendMessage(SendMessage message)
{
// Discord bridge isn't ready, so just reject the message instead of attempting to send it
if (!_discordBot.DiscordClient.Ready)
{
await this.Clients.Caller.SendAsync("BridgeDown");
}
// Sanitise the message contents
NewMessage newMessage = new NewMessage(RemoveMassPings(message.Content));
// Get the internal user by the connection ID mapping
HubUser hubUser = UserHandler.UserMappings[this.Context.ConnectionId];
BridgeMessage bridgeMessage = new BridgeMessage();
// Parse the logged in user's name into a Discord ID.
// Maybe add a check here if it fails? Users should only be able to create accounts with names from their Discord IDs
// but unclear what happens if db is corrupted etc.
ulong.TryParse(this.Context.User.Identity.Name, out ulong userId);
bridgeMessage.UserId = userId;
bridgeMessage.SignalRMessage = newMessage;
// Send the message to the Discord client
await _discordBot.DiscordClient.IngestSignalR(bridgeMessage);
// Tell other clients to stop the typing indicator
await this.Clients.Others.SendAsync("StopTypingForClient", hubUser);
}
protected override async void TcpListener_ContentReceived(object sender, TcpListenerContentReceivedArgs e)
{
try
{
await SocketService.SendToDeviceAsync(TcpListener.Socket, null, "confirmReceipt", e.ReceivedContent);
BridgeMessage message = SocketService.TryParseMessage(e.ReceivedContent);
if (App.ApiSettings == null)
{
string apiSettings = message.ApiSettings;
App.ApiSettings = JsonConvert.DeserializeObject <ApiSettings>(apiSettings);
}
if (App.PairedHost == null)
{
HostName hostIp = new HostName(message.IpFrom);
App.PairedHost = hostIp;
TcpClient = new TcpClient(hostIp, port);
await TcpClient.ConnectAsync();
}
RunBridgedAction(message.Action, message.Parameter);
}
catch (Exception)
{
var error = TcpClient.ErrorStatus;
throw;
}
}
protected override void Execute()
{
var context = frame.V8Context;
var msg = BridgeMessage.Create(EVALUATE_JS_CALLBACK);
msg.Arguments.Add(MessageValue.CreateInt(taskId));
if (context.TryEval(code, frame.Url, 0, out CefV8Value retval, out CefV8Exception v8Exception))
{
context.Enter();
try
{
var jsvalue = retval.ToJSValue();
msg.Arguments.Add(MessageValue.CreateBool(true));
msg.Arguments.Add(MessageValue.CreateString(jsvalue.ToDefinition()));
}
catch (Exception ex)
{
msg.Arguments.Add(MessageValue.CreateBool(false));
msg.Arguments.Add(MessageValue.CreateString(ex.Message));
}
finally
{
context.Exit();
}
}
protected override void Execute()
{
var cachedFuncInfo = JavaScriptObjectRepository.RenderSideFunctions.SingleOrDefault(x => x.Id == functionId);
if (cachedFuncInfo == null)
{
return;
}
var func = cachedFuncInfo.Function;
var context = cachedFuncInfo.Context;
var msg = BridgeMessage.Create(EVALUATE_JS_CALLBACK);
msg.Arguments.Add(MessageValue.CreateInt(taskId));
context.Enter();
CefV8Value[] argumentList = null;
CefV8Value result = null;
try
{
argumentList = arguments.ToCefV8Arguments();
result = func.ExecuteFunctionWithContext(context, null, argumentList);
}
finally
{
if (argumentList != null)
{
foreach (var value in argumentList)
{
value.Dispose();
}
}
context.Exit();
}
if (result != null)
{
var jsvalue = result.ToJSValue();
msg.Arguments.Add(MessageValue.CreateBool(true));
msg.Arguments.Add(MessageValue.CreateString(jsvalue.ToDefinition()));
result.Dispose();
}
else
{
msg.Arguments.Add(MessageValue.CreateBool(false));
msg.Arguments.Add(MessageValue.CreateString("Executing function failed."));
}
jsbridge.SendProcessMessage(frame, msg);
}
public override void SendMessage(BridgeMessage message)
{
this.dispatcherService.RunAsync(
() =>
{
this.webViewControl.InvokeScript(
JsFunction,
new[] { JsContextName, JsonConvert.SerializeObject(message) });
});
}
/// <summary>
/// The main Send method. Called both by the unicast code and as a result of calls from the BeaconService thread.
/// </summary>
/// <param name="buf"></param>
public void Send(byte[] buf, int length, MessageTags tags)
{
BridgeMessage bmsg = new BridgeMessage(new BufferChunk(buf, 0, length), tags.BridgePriority);
if (m_SendQueue != null)
{
lock (m_SendQueue) {
m_SendQueue.Enqueue(bmsg);
m_SendQueueWait.Set();
}
}
}
public override void SendMessage(BridgeMessage message)
{
var dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
this.webViewControl.InvokeScriptAsync(
JsFunction,
new[] { JsContextName, JsonConvert.SerializeObject(message) });
});
}
public override void SendMessage(BridgeMessage message)
{
var msg = JsonConvert.SerializeObject(message);
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(msg);
string encoded = System.Convert.ToBase64String(plainTextBytes);
this.activity.RunOnUiThread(
() =>
{
this.webViewControl.LoadUrl("javascript:" + JsFunction + "('" + JsContextName + "', '" + encoded + "');");
});
}
protected virtual async ValueTask OnUnsupportedRequest(BridgeMessage request, CancellationToken cancellationToken)
{
if (request is ReplicaRequest rr)
{
var reply = new PublicationAbsentsReply()
{
PublisherId = rr.PublisherId,
PublicationId = rr.PublicationId,
};
await Channel.Writer
.WriteAsync(reply, cancellationToken)
.ConfigureAwait(false);
}
}
/// <summary>
/// Get Message Response
/// </summary>
public virtual BridgeMessage GetMessage()
{
GetMessageResponse getMsg = (GetMessageResponse)this.IpmiSendReceive(
new GetMessageRequest(), typeof(GetMessageResponse));
BridgeMessage response = new BridgeMessage(getMsg.CompletionCode);
if (getMsg.CompletionCode == 0x00)
{
response.SetParamaters(getMsg.MessageData);
}
return(response);
}
// No need to authorize it here because it already checks for the Manage Messages
// permission in the Discord side.
/// <summary>
/// Attempts to delete the requested message from the Discord channel.
/// </summary>
/// <param name="message">The message to delete.</param>
/// <returns>A Task representing the state of the request.</returns>
public async Task DeleteMessage(DeleteRequest message)
{
// Create a new DeleteMessage object using the ID from the deletion request
DeleteMessage deleteMessage = new DeleteMessage(message.Id);
BridgeMessage bridgeMessage = new BridgeMessage();
ulong.TryParse(this.Context.User.Identity.Name, out ulong userId);
bridgeMessage.UserId = userId;
bridgeMessage.SignalRMessage = deleteMessage;
await _discordBot.DiscordClient.IngestSignalR(bridgeMessage);
}
protected virtual async ValueTask OnUnsupportedMessage(BridgeMessage message, CancellationToken cancellationToken)
{
if (message is ReplicaMessage rm)
{
var response = new PublicationAbsentsMessage()
{
PublisherId = rm.PublisherId,
PublicationId = rm.PublicationId,
};
await Channel.Writer
.WriteAsync(response, cancellationToken)
.ConfigureAwait(false);
}
}
/// <summary>
/// Send sync Bridge Command
/// </summary>
/// <param name="channel">Channel to send command (Intel ME = 6)</param>
/// <param name="slaveId">Channel Slave Id</param>
/// <param name="messageData">Message payload</param>
public virtual BridgeMessage SendMessage(byte channel, byte slaveId, byte[] requestMessage)
{
SendMessageResponse sendmsg = (SendMessageResponse)this.IpmiSendReceive(
new SendMessageRequest(channel, requestMessage),
typeof(SendMessageResponse));
BridgeMessage response = new BridgeMessage(sendmsg.CompletionCode);
if (sendmsg.CompletionCode == 0x00)
{
response.SetParamaters(sendmsg.MessageData);
}
return(response);
}
public static string SerializeMessage(string apiSettings, string action, string param)
{
var dataObj = new BridgeMessage()
{
Timestamp = DateTime.Now,
IpFrom = NetworkPresenter.GetCurrentIpv4Address(),
ApiSettings = apiSettings,
Action = action,
Parameter = param
};
string body = JsonConvert.SerializeObject(dataObj, Formatting.None, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
return(body);
}
private async void HandleConfirmedMessage(BridgeMessage confirmedMessage)
{
switch (confirmedMessage.Action)
{
case "authDevice":
await DispatcherHelper.RunAsync(() => { IsConnectedToDevice = true; });
break;
case "logoutUser":
await DispatcherHelper.RunAsync(() => { IsConnectedToDevice = false; });
break;
default:
break;
}
}
public void Error(string text = "Invalid operation")
{
if (_isCalled)
{
throw new InvalidOperationException();
}
var message = BridgeMessage.Create(JavaScriptCommunicationBridge.EXECUTE_JAVASCRIPT_FUNCTION);
//message.Arguments.Add(MessageValue.CreateString(_objectKey));
//message.Arguments.Add(MessageValue.CreateString(_name));
message.Arguments.Add(MessageValue.CreateBool(false));
message.Arguments.Add(MessageValue.CreateString(text));
message.Arguments.Add(MessageValue.CreateString($"{_uuid}"));
_jsBridge.SendProcessMessage(_frame, message);
_isCalled = true;
}
protected override void Execute()
{
var message = BridgeMessage.Create(JS_OBJECT_MAPPING_MESSAGE);
var args = JavaScriptValue.CreateObject();
foreach (var obj in jsbridge.RegisteredJavaScriptObjects)
{
if (obj.Value != null)
{
args.SetValue(obj.Key, obj.Value);
}
}
message.Arguments.Add(MessageValue.CreateString(args.ToDefinition()));
jsbridge.SendProcessMessage(frame, message);
jsbridge.IsObjectsMapped = true;
}
public void Success(params JavaScriptValue[] retvals)
{
if (_isCalled)
{
throw new InvalidOperationException();
}
var message = BridgeMessage.Create(JavaScriptCommunicationBridge.EXECUTE_JAVASCRIPT_FUNCTION);
message.Arguments.Add(MessageValue.CreateBool(true));
var retval = retvals?.ToJSValue() ?? JavaScriptValue.CreateArray();
message.Arguments.Add(MessageValue.CreateString(retval.ToDefinition()));
message.Arguments.Add(MessageValue.CreateString($"{_uuid}"));
_jsBridge.SendProcessMessage(_frame, message);
_isCalled = true;
}
/// <summary>
/// Watch the queue; Send messages as they are available
/// </summary>
private void SendThread()
{
while (!m_Disposing)
{
BridgeMessage bmsg = null;
lock (m_SendQueue) {
while (m_SendQueue.Count > 0)
{
bmsg = m_SendQueue.Dequeue();
if ((m_SendQueue.Count < 5) || !(bmsg.BridgePriority.Equals(MessagePriority.RealTime)))
{
break;
}
}
}
if (bmsg != null)
{
if (m_RtpSender != null)
{
try {
Trace.WriteLine("Bridge Sending frame; size=" + bmsg.Buffer.Length.ToString() + ";priority=" + bmsg.BridgePriority.ToString());
m_RtpSender.Send(bmsg.Buffer); //This is a synchronous call that may take a significant amount of time to return.
}
catch (ObjectDisposedException) {
//This happens when we dispose the MSR stuff. No big deal.
Trace.WriteLine("ObjectDisposedException in RtpSender.Send", this.GetType().ToString());
}
catch (Exception e) {
Trace.WriteLine(e.ToString());
}
}
}
else
{
m_SendQueueWait.WaitOne();
}
}
}
private async void ProcessReceivedMessage(string message)
{
try
{
BridgeMessage response = SocketService.TryParseMessage(message);
switch (response.Action)
{
case "confirmReceipt":
BridgeMessage confirmedMessage = JsonConvert.DeserializeObject <BridgeMessage>(response.Parameter);
HandleConfirmedMessage(confirmedMessage);
break;
case "refreshData":
if (CurrentViewModel != null)
{
await DispatcherHelper.RunAsync(async() => {
await CurrentViewModel.RefreshDataAsync();
});
}
break;
case "roundsEnded":
await DispatcherHelper.RunAsync(() => {
IsConnectedToDevice = false;
});
break;
default:
break;
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Fire this after receiving a message from the web bridge.
/// Current actions supported: Send, Delete
/// </summary>
/// <param name="message">The message coming from the SignalR hub.</param>
/// <returns>The task representing the message's processing status.</returns>
public async Task IngestSignalR(BridgeMessage message)
{
if (!Ready)
{
throw new NullReferenceException("Guild not found.");
}
if (message.SignalRMessage.Action == "NewMessage")
{
DiscordChannel bridgeChannel = await this.discordClient.GetChannelAsync(ChannelId);
DiscordMember guildMember = await bridgeChannel.Guild.GetMemberAsync(message.UserId);
NewMessage newMessage = message.SignalRMessage as NewMessage;
MatchCollection colonEmotes = Regex.Matches(newMessage.Content, @":[a-zA-Z0-9_~]+:(?!\d+)");
string translatedContent = newMessage.Content;
List <string> translatedEmotes = new List <string>(colonEmotes.Count);
foreach (Match colonEmote in colonEmotes)
{
if (translatedEmotes.Contains(colonEmote.Value))
{
break;
}
try
{
DiscordEmoji emote = DiscordEmoji.FromName(discordClient, colonEmote.Value);
if (emote.Id == 0)
{
translatedContent = translatedContent.Replace(colonEmote.Value, emote.Name);
}
else if (emote.IsAnimated)
{
translatedContent = translatedContent.Replace(colonEmote.Value, $"<a:{emote.Name}:{emote.Id}>");
}
else if (!emote.IsAnimated)
{
translatedContent = translatedContent.Replace(colonEmote.Value, $"<:{emote.Name}:{emote.Id}>");
}
translatedEmotes.Add(colonEmote.Value);
}
catch
{
// The emote doesn't exist on the target server, or it's been deleted.
// Just do nothing (don't attempt to translate it)
}
}
if (guildMember == null)
{
throw new UnauthorizedAccessException("Not in Discord guild.");
}
else
{
await webhookClient.Webhooks[0].ExecuteAsync(new DiscordWebhookBuilder()
{
Content = translatedContent,
Username = guildMember.DisplayName,
AvatarUrl = guildMember.AvatarUrl,
IsTTS = false
});
}
}
else if (message.SignalRMessage.Action == "DeleteMessage")
{
DiscordChannel bridgeChannel = await this.discordClient.GetChannelAsync(ChannelId);
DiscordMember guildMember = await bridgeChannel.Guild.GetMemberAsync(message.UserId);
if (guildMember == null)
{
return;
}
if (bridgeChannel.PermissionsFor(guildMember).HasPermission(Permissions.ManageMessages))
{
DiscordMessage delMessage = await bridgeChannel.GetMessageAsync(ulong.Parse(message.SignalRMessage.MessageId));
await delMessage.DeleteAsync();
return;
}
// Nothing to do, user doesn't have permission to delete the message.
return;
}
else
{
throw new InvalidOperationException("Undefined action.");
}
}
public override void SendMessage(BridgeMessage message)
{
this.webViewControl.FireEvent(JsFunction, new[] { JsContextName, JsonConvert.SerializeObject(message) });
}
public override void SendMessage(BridgeMessage message)
{
var msg = JsonConvert.SerializeObject(message).Replace("\\r\\n", "").Replace("\\", "\\\\");
this.webViewControl.LoadUrl("javascript:" + JsFunction + "('" + JsContextName + "', '" + msg + "');");
}
public void OnReceiveMessage(BridgeMessage bridgeMessage)
{
this.OnMessageReceived(bridgeMessage);
}
public override void SendMessage(BridgeMessage message)
{
this.Action(message);
}
public void MessageSent(object sender, BridgeMessage bridgeMessage)
{
this.clientsCaller.receiveMessage(JsContextName, bridgeMessage);
}
public override void SendMessage(BridgeMessage message)
{
this.webViewControl.LoadUrl("javascript:" + JsFunction + "('" + JsContextName + "', '" + JsonConvert.SerializeObject(message) + "');");
}
public override void SendMessage(BridgeMessage message)
{
this.MessageSent?.Invoke(this, message);
}
