public static Task SendError(
[ServiceBusTrigger("%BROADCASTER_ERROR_QUEUE%", Connection = "BROADCASTER_CONNECTION_STRING")]
ErrorMessageToReceiver errorMessage,
[SignalR(HubName = "%COMMUNICATION_HUB_NAME%")]
IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
var broadcastMessage = new SignalRMessage
{
Target = Environment.GetEnvironmentVariable("TARGET_ERROR"),
Arguments = new object[]
{
new
{
utcTimestamp = errorMessage.UtcTimestamp,
from = errorMessage.From,
message = errorMessage.MessageText
}
}
};
if (string.IsNullOrWhiteSpace(errorMessage.To) == false)
{
broadcastMessage.UserId = errorMessage.To;
}
// If Exception is not null, do what ever you like ;)
return(signalRMessages.AddAsync(broadcastMessage));
}
public static Task SendWarning(
[ServiceBusTrigger("%BROADCASTER_WARNING_QUEUE%", Connection = "BROADCASTER_CONNECTION_STRING")]
BroadcastMessageToReceiver warningMessage,
[SignalR(HubName = "%COMMUNICATION_HUB_NAME%")]
IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
var broadcastMessage = new SignalRMessage
{
Target = Environment.GetEnvironmentVariable("TARGET_WARNING"),
Arguments = new object[]
{
new
{
utcTimestamp = warningMessage.UtcTimestamp,
from = warningMessage.From,
message = warningMessage.MessageText
}
}
};
if (string.IsNullOrWhiteSpace(warningMessage.To) == false)
{
broadcastMessage.UserId = warningMessage.To;
}
return(signalRMessages.AddAsync(broadcastMessage));
}
public async Task <IActionResult> PostSubmission(
[HttpTrigger(AuthorizationLevel.Anonymous, "POST", Route = "submission/{user}")] HttpRequest httpRequest,
string user,
[SignalR(HubName = "SubmissionHub")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
log.LogInformation($"Request Submitted for '{user}'.");
if (string.IsNullOrWhiteSpace(user))
{
throw new ArgumentException("Cannot be null or empty.", nameof(user));
}
var request = new SubmitForApproval(user);
var response = await mediator.Send(request);
var message = new SignalRMessage
{
Target = $"broadcastMessage",
Arguments = new[] { request.UserId, "submitted" }
};
await signalRMessages.AddAsync(message);
return(new OkObjectResult(response));
}
public async Task Messages_Are_Dispatched_To_Hooks_Observable()
{
// Sanity check
_messageHandler.Should().NotBeNull();
var recipients = A.CollectionOfFake <SignalRMessageRecipient>(3);
var message = new SignalRMessage
{
HubTypeName = "MyHub",
Method = "Foo",
Args = new object[] { "Hello", 42 },
Recipients = recipients.ToArray()
};
var tcs = new TaskCompletionSource <MessageHook>();
using var sub = _hooks
.Subscribe(x => tcs.TrySetResult(x));
await _messageHandler(message, CancellationToken.None);
var actual = await tcs.Task;
actual.HubTypeName.Should().Be(message.HubTypeName);
actual.Method.Should().Be(message.Method);
actual.Args[0].Should().Be(message.Args[0]);
}
public static async Task NotifyParticipants(
[ActivityTrigger] IDurableActivityContext context,
[SignalR(HubName = SignalRHubName)] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
string appointmentId = context.InstanceId;
var appointment = context.GetInput <Appointment>();
var nickNames = appointment.Participants.ToArray();
foreach (string nickName in nickNames)
{
var signalRMessage = new SignalRMessage
{
UserId = nickName,
Target = "appointment-state-changed",
Arguments = new[]
{
new
{
id = appointmentId,
participants = nickNames,
status = appointment.Status
}
}
};
await signalRMessages.AddAsync(signalRMessage);
}
}
public static async Task Run([CosmosDBTrigger(
databaseName: "db",
collectionName: "updates",
ConnectionStringSetting = "CosmosDB",
LeaseCollectionName = nameof(PushMessageFromCosmos),
CreateLeaseCollectionIfNotExists = true)] IReadOnlyList <Message> documents,
[SignalR(HubName = "chat")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
var format = new SignalRMessage {
Target = "newFile",
Arguments = new Message[1]
};
SignalRMessage Create(Message msg)
{
format.Arguments[0] = msg; return(format);
}
foreach (var msg in documents)
{
if (msg.Tags.Length > 1)
{
await signalRMessages.AddAsync(Create(msg));
}
}
}
public static SignalRMessage[] FromJSON(JSONClass json)
{
List <SignalRMessage> result = new List <SignalRMessage>();
if (json.ContainsKey("M") && json["M"].AsArray != null)
{
foreach (JSONNode node in json["M"].AsArray)
{
SignalRMessage msg = new SignalRMessage();
msg.H = node.AsObject.ContainsKey("H") ? node.AsObject["H"].Value : string.Empty;
msg.M = node.AsObject.ContainsKey("M") ? node.AsObject["M"].Value : string.Empty;
if (node.AsObject.ContainsKey("A") && node.AsObject["A"].AsArray != null)
{
List <string> paramsA = new List <string>();
foreach (JSONNode nodeParam in node.AsObject["A"].AsArray)
{
paramsA.Add(nodeParam.Value);
}
msg.A = paramsA.ToArray();
}
result.Add(msg);
}
}
return(result.ToArray());
}
void _ws_OnMessage(object sender, MessageEventArgs e)
{
JSONClass json = JSON.Parse(e.Data).AsObject;
#if UNITY_EDITOR
UnityEngine.Debug.Log(e.Data);
#endif
if (json.ContainsKey("E"))
{
UnityMainThreadDispatcher.Instance().Enqueue(() => onConnectionUpdate(ConnectionStatus.ERROR));
}
else
{
UnityMainThreadDispatcher.Instance().Enqueue(() => onConnectionUpdate(ConnectionStatus.CONNECTED));
var msgs = SignalRMessage.FromJSON(json);
foreach (var msg in msgs)
{
switch (msg.M)
{
case "remoteCommand":
RemoteCommand cmd = (RemoteCommand)System.Enum.Parse(typeof(RemoteCommand), msg.A[0].ToUpper());
var param = msg.A.Length > 1 ? msg.A[1] : string.Empty;
UnityMainThreadDispatcher.Instance().Enqueue(() => onRemoteCommand(cmd, param));
break;
}
}
}
}
private void SendMessageThread(object obj)
{
CancellationToken ct = (CancellationToken)obj;
IList <Message> msgs;
var cntx = Cntx;
var set = new SignalRMessageSet();
var msgsvc = new SignalRMessageServiceProxy();
while (!ct.IsCancellationRequested)
{
msgs = MessageQueue.Take(ct);
if (msgs != null && !ct.IsCancellationRequested)
{
SignalRMessage entity = new SignalRMessage
{
ApplicationID = config.App.ID,
TimeStamp = DateTime.UtcNow.Ticks,
MesssageData = (new ScaleoutMessage(msgs)).ToBytes()
};
try
{
msgsvc.AddOrUpdateEntities(cntx, set, new SignalRMessage[] { entity });
lastSent = DateTime.Now;
}
catch
{
}
}
}
}
public static async Task Run(
[CosmosDBTrigger(
databaseName: "%ThermostatLogDatabaseName%",
collectionName: "%ThermostatLogCollectionName%",
ConnectionStringSetting = "CosmosConnectionString",
LeaseCollectionName = "leases",
LeaseCollectionPrefix = "%ThermostatLogLeasePrefix%",
CreateLeaseCollectionIfNotExists = true,
StartFromBeginning = false)] IReadOnlyList <Document> input,
[SignalR(HubName = "readings", ConnectionStringSetting = "AzureSignalRConnectionString")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
foreach (var doc in input)
{
var thermostatLog = JsonConvert.DeserializeObject <ThermostatLog>(doc.ToString());
var min = thermostatLog.Readings.Select(x => x.Temp).Min();
var avg = thermostatLog.Readings.Select(x => x.Temp).Average();
var max = thermostatLog.Readings.Select(x => x.Temp).Max();
var readingString = $"MinTemp: {min:F2}, AvgTemp: {avg:F2}, MaxTemp: {max:F2}";
log.LogInformation($"{thermostatLog.DeviceId}, {readingString}");
var message = new SignalRMessage
{
Target = "newReading",
Arguments = new[] { new { sender = thermostatLog.DeviceId.ToString(), text = readingString } }
};
await signalRMessages.AddAsync(message);
}
}
public async Task SendGroupExceptAsync_Delegates_To_Message_Sender_And_Publishes_Message_To_Group_Recipient_Except_Specified()
{
string methodName = Guid.NewGuid().ToString();
var args = new object[] { 42, "hello world" };
var groupName = "mygroup";
var excludedConnectionIds = new[] { Guid.NewGuid().ToString() };
SignalRMessage message = null;
A.CallTo(() => _serviceBusPublisher.PublishAsync(A <SignalRMessage> ._))
.Invokes((SignalRMessage m) => message = m);
await _lifetimeManager.SendGroupExceptAsync(groupName, methodName, args, excludedConnectionIds, CancellationToken.None);
A.CallTo(() => _messageSender.SendGroupExceptAsync(groupName, methodName, args, excludedConnectionIds, CancellationToken.None))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _serviceBusPublisher.PublishAsync(A <SignalRMessage> ._))
.MustHaveHappenedOnceExactly();
ValidateCommonMessageProperties(message);
ValidateMethodAndArgs(message, methodName, args);
ValidateSingleRecipient <GroupMessageRecipient>(message, r =>
{
r.GroupName.Should().Be(groupName);
r.ExcludedConnectionIds.Should().Equal(excludedConnectionIds);
});
}
public static async Task Run2(
[ServiceBusTrigger("signalr", Connection = "AzureWebJobsServiceBus")]
string receivedMessage,
IDictionary <string, object> userProperties,
[SignalR(HubName = "SbHub")] IAsyncCollector <SignalRMessage> outMessage,
ILogger log,
CancellationToken token
)
{
var msg = JObject.Parse(receivedMessage);
log.LogInformation($"Receive signalr message {msg}");
var p = new SignalRMessage
{
Target = "Message",
Arguments = new object[] { msg },
};
if (userProperties.TryGetValue("userId", out var userId))
{
p.UserId = userId?.ToString();
}
if (userProperties.TryGetValue("group", out var group))
{
p.GroupName = @group?.ToString();
}
await outMessage.AddAsync(p, token);
}
public async Task Messages_Are_Dispatched_To_Recipients()
{
await _dispatcher.StartAsync(CancellationToken.None);
// Sanity check
_messageHandler.Should().NotBeNull();
var recipients = A.CollectionOfFake <SignalRMessageRecipient>(3);
var message = new SignalRMessage
{
HubTypeName = "MyHub",
SenderId = Guid.NewGuid(),
Method = "Foo",
Args = new object[] { "Hello", 42 },
Recipients = recipients.ToArray()
};
await _messageHandler(message, CancellationToken.None);
foreach (var recipient in recipients)
{
A.CallTo(() => recipient.SendCoreAsync(_messageSender, message.Method, message.Args, A <CancellationToken> ._))
.MustHaveHappenedOnceExactly();
}
}
public static async Task <SignalRMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log, ExecutionContext context)
{
log.LogInformation("C# HTTP trigger function processed a request to analyze image.");
var ms = new MemoryStream();
await req.Body.CopyToAsync(ms);
var imageBytes = ms.ToArray();
var identified = await FaceConnector.AnalyzeImageAsync(imageBytes, GetConfig(log, context));
identified.ToList().ForEach(_ =>
{
log.LogInformation(_.UserData);
});
dynamic data = new ExpandoObject();
var message = new SignalRMessage
{
Target = "ImageAnalyzed"
};
var content = new AnalyzeResult
{
NrFound = identified.Count(),
Users = identified.Select(_ => _.UserData).ToList()
};
data.result = content;
message.Arguments = new object[] { data };
return(message);
}
public CloudInteractions(SignalRMessage inboundMessage, SignalRMessage outgoingMessage,
Settings settings, OnlineSettings onlineSettings)
{
//connection = new HubConnectionBuilder()
// .WithUrl("https://clipmanagerweb.azurewebsites.net/broadcast").Build();
var baseUrl = "https://clipboardmonitorlitefunctions.azurewebsites.net";
var connection = new HubConnectionBuilder()
.WithUrl($"{baseUrl}/api")
.Build();
_settings = settings;
_inboundMessage = inboundMessage;
_outgoingMessage = outgoingMessage;
_onlineSettings = onlineSettings;
_function = new ApiFunction(_onlineSettings);
OnlineState.ConnectionLife = connection.State.ToString();
if (_settings.OnlineMode)
{
StartListening();
}
_settings.PropertyChanged += OnlineModeChanged;
_outgoingMessage.PropertyChanged += NewMessageToSend;
}
public async Task Detect(
[BlobTrigger("gifts/{fileName}", Connection = "AzureWebJobsStorage")] Stream blob,
string fileName,
[SignalR(HubName = SignalRHandler.HubName)] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log
)
{
try
{
var tags = await _visionService.GetTags(blob);
var compared = _giftValidator.All(t => tags.Contains(t.ToLower()));
var message = new SignalRMessage()
{
Target = "broadcastMessage"
};
message.Arguments = new object[]
{
new
{
FileName = fileName,
Result = compared
}
};
await signalRMessages.AddAsync(message);
}
catch (Exception e)
{
log.LogCritical(e, e.Message);
throw;
}
}
protected async override void OnAppearing()
{
if (DIContainer.SignalRClient.GetHubConnection().State == HubConnectionState.Connected && signalRMessages.Count == 0)
{
DIContainer.SignalRClient.GetHubConnection().On <string>(Constants.SIGNALR_HUB_SENDMESSAGE, (message) =>
{
var msg = JsonSerializer.Deserialize <SignalRMessage>(message);
signalRMessages.Add(msg);
});
}
var result = await DIContainer.Scan.ScanAsync();
if (!string.IsNullOrEmpty(result))
{
UpsertProperties(Constants.SIGNALR_USER_KEY, result);
var id = await DIContainer.SignalRClient.GetConnectionId();
var message = new SignalRMessage(true, id);
var textForSend = System.Text.Json.JsonSerializer.Serialize(message);
await DIContainer.SignalRClient.SendMessage(result, textForSend, Constants.SIGNALR_HUB_NEGOTIATE);
Vibration.Vibrate();
}
}
private void ValidateSingleRecipient <TRecipient>(SignalRMessage message, Action <TRecipient> recipientAssertions = null)
{
message.Recipients.Should().HaveCount(1);
var recipient = message.Recipients.Single();
var typedRecipient = recipient.Should().BeOfType <TRecipient>().Subject;
recipientAssertions?.Invoke(typedRecipient);
}
private void MessageArrived(SignalRMessage message)
{
if ((_settings.LimitTraffic && !_settings.SendOnly) || (!_settings.LimitTraffic))
{
_inboundMessage.Content = message.Content;
_inboundMessage.MachineName = message.MachineName;
}
}
public async Task PublishAsync(SignalRMessage message)
{
_hooks.OnNext(new MessageHook(message.HubTypeName, message.Method, message.Args));
foreach (var other in _buffers)
{
await other.Add(message);
}
}
public static void SendMessage(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req, [SignalR(HubName = "<hub_name>")] out SignalRMessage message)
{
message = new SignalRMessage
{
Target = "<target>",
Arguments = new[] { "<here_can_be_multiple_objects>" }
};
}
public static async Task SendReminder(
[TimerTrigger("0 0 * * * *")] TimerInfo myTimer,
[Table("reminders", Connection = "AzureWebJobsStorage")] CloudTable reminderTable,
[TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From = "+16177670668")] IAsyncCollector <CreateMessageOptions> messages,
[SignalR(HubName = "ReminderHub")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
// get id (hour)
string hour = Utilities.GetEasternDateTime(log).AddMinutes(5).Hour.ToString();
// get row by id
var findOperation = TableOperation.Retrieve <ReminderTableEntity>(Mappings.PartitionKey, hour);
var findResult = await reminderTable.ExecuteAsync(findOperation);
// check if not found
if (findResult.Result == null)
{
return;
}
// grab current text
var existingRow = (ReminderTableEntity)findResult.Result;
var message = existingRow.Message;
// if we got something, let's do some updates
if (!string.IsNullOrEmpty(message))
{
// clear current reminder text
var existingReminder = (ReminderTableEntity)findResult.Result;
existingReminder.Message = "";
// update existing reminder
var replaceOperation = TableOperation.Replace(existingReminder);
await reminderTable.ExecuteAsync(replaceOperation);
// create sms message
var reminderPhone = Environment.GetEnvironmentVariable("ReminderNumber");
var smsMessage = new CreateMessageOptions(new PhoneNumber(reminderPhone))
{
Body = message
};
await messages.AddAsync(smsMessage);
log.LogInformation($"Sending reminder for hour {hour} with message {message}");
// send client update
var returnReminder = existingReminder.ToModel();
var signalRMessage = new SignalRMessage
{
Target = "updateReminder",
Arguments = new[] { returnReminder }
};
await signalRMessages.AddAsync(signalRMessage);
}
}
public ClipboardManager(SignalRMessage inboundMessage, SignalRMessage outgoingMessage, Settings settings)
{
ClipboardUpdate += ClipboardChangeEvent_ClipboardUpdate;
_settings = settings;
form = new NotificationForm();
_inboundMessage = inboundMessage;
_outgoingMessage = outgoingMessage;
TextFromCloud = false;
_inboundMessage.PropertyChanged += NewInboundMessage;
}
public static void ClearCanvas(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
[SignalR(HubName = "serverlessdraw")] out SignalRMessage message,
ILogger log)
{
message = new SignalRMessage {
Target = "clearCanvas",
Arguments = new object[0]
};
}
public static SignalRMessage CreateMessage(BackgroundJobStatus payload)
{
var message = new SignalRMessage
{
Target = HubStatusUpdateTarget,
Arguments = new[] { payload }
};
return(message);
}
protected void BroadcastResourceChange(ModelAction action)
{
var signalRMessage = new SignalRMessage
{
Name = Resource,
Body = new ResourceChangeMessage <TResource>(action)
};
_signalRBroadcaster.BroadcastMessage(signalRMessage);
}
protected void BroadcastResourceChange(ModelAction action)
{
var signalRMessage = new SignalRMessage
{
Name = Resource,
Body = new ResourceChangeMessage <TResource>(action)
};
_commandExecutor.PublishCommand(new BroadcastSignalRMessage(signalRMessage));
}
async Task UserChangedTableStatus(int tableId, string status)
{
var msg = new SignalRMessage()
{
target = "StatusChanged",
arguments = new object[] { tableId, status }
};
await signalRApiClient.BroadcastToAllClients(senderUserId : "user-x", hubName : "default", msg);
}
public async Task ConnectAsync()
{
await _signalRService.Connect();
_signalRService.OnMessageReceive((name, message) => {
var messageObj = new SignalRMessage {
Name = name, Message = message
};
Messages.Add(messageObj);
});
}
public async Task <IActionResult> Post([FromBody] SignalRMessage message)
{
try
{
await _commandDispatcher.DispatchAsync(_hubContext.SendMessage, message);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}