public long CreateBroadcast(CfBroadcastRequest createBroadcast) { var broadcastRequest = new BroadcastRequest(createBroadcast.RequestId, BroadcastMapper.ToSoapBroadcast(createBroadcast.Broadcast)); var resourcerReference = BaseRequest <ResourceReference>(HttpMethod.Post, broadcastRequest, new CallfireRestRoute <Broadcast>()); return(resourcerReference.Id); }
public IActionResult Broadcast([FromBody] BroadcastRequest request) { var now = DateTimeOffset.UtcNow; _hubContext.Clients.All.SendAsync("send", now, request.System, request.Message); return(Ok($"Broadcast performed {now}/{request.System}")); }
public void sendMessage(string message) { BroadcastRequest request = new BroadcastRequest() { message = message, userName = Properties.Settings.Default.Config.userName }; ClientEvents.invokeMessageSent(request); }
public void UpdateBroadcast(CfBroadcastRequest updateBroadcast) { var broadcast = updateBroadcast.Broadcast; if (broadcast == null) { return; } var broadcastRequest = new BroadcastRequest(updateBroadcast.RequestId, BroadcastMapper.ToSoapBroadcast(broadcast)); BaseRequest <string>(HttpMethod.Put, broadcastRequest, new CallfireRestRoute <Broadcast>(broadcast.Id)); }
public void sendMessage(BroadcastRequest request) { byte[] packet = SharedEncoding.encryptBroadcastRequest(request, config.key); if (stream != null) { try { stream.WriteAsync(packet, 0, packet.Length); } catch (Exception e) { MessageBox.Show("ERROR: Cannot send message"); } } else { MessageBox.Show("ERROR: Cannot send message"); } }
private void ProcessRequests(CancellationToken token) { while (!token.IsCancellationRequested) { // process all incoming request from the queue if (_awaitingRequests.IsEmpty || !_awaitingRequests.TryDequeue(out IRequest request)) { continue; } lock (_locker) { // transform request operations according to the current server state IRequest transformedRequest = TransformRequest(request); // apply operations over the server data document ApplyOperations(transformedRequest); // save operations to the server revision log _revisionLog.TryAdd(_revision, transformedRequest.Operations.ToList()); // acknowledge the request IRequest acknowledgedRequest = RequestFactory.CreateRequest( transformedRequest.ClientId, _revision + 1, transformedRequest.Operations.ToList(), true); // broadcast operations to other clients if (BroadcastRequest != null) { BroadcastRequest.Invoke(acknowledgedRequest); } // increment local revision _revision++; } } }
private void Main() { while (client.Connected) { if (stream.DataAvailable) { byte[] buffer = new byte[1024]; stream.Read(buffer, 0, buffer.Length); if (SharedPacketTranslation.isBrodcastRequest(buffer)) { BroadcastRequest request = SharedEncoding.decryptBroadcastRequest(buffer, config.key); ClientEvents.invokeMessageRecived(request); } else if (SharedPacketTranslation.isNotificationRequest(buffer)) { NotificationRequest notification = SharedEncoding.decodeNotificationRequest(buffer); ClientEvents.invokeNotificationReceived(notification); } } Thread.Sleep(100); } }
public void receiveMessage(BroadcastRequest message) { messagesToDisplay.Add(message); }
private IEnumerable UpdateLoop() { while (true) { yield return(null); List <ItemData> items = new List <ItemData>(); Player.Health.GetStatusEffectData(items, true); Player.Inventory.GetEquipmentData(items); items.Sort(new ItemDataComparer()); if (CompareLists(items, lastItems) && Time.time < lastBroadcast + 10) { continue; } lastItems = items; lastBroadcast = Time.time; var currentItems = new CurrentItems(); foreach (var item in items) { Logger.Debug(item.guid); if (item == null) { continue; } if (item.Hint.HasFlag(ItemData.ItemHint.Relic)) { currentItems.relics.Add(item.guid); } if (item.Hint.HasFlag(ItemData.ItemHint.Blessing)) { currentItems.blessings.Add(item.guid); } if (item.Hint.HasFlag(ItemData.ItemHint.Curse)) { currentItems.curses.Add(item.guid); } if (item.Hint.HasFlag(ItemData.ItemHint.Potion)) { currentItems.potions.Add(item.guid); } } var message = JsonUtility.ToJson(currentItems); var broadcastRequest = new BroadcastRequest(message); var req = JsonUtility.ToJson(broadcastRequest); var reqBytes = Encoding.UTF8.GetBytes(req); var url = $"https://api.twitch.tv/v5/extensions/message/{userID}"; UnityWebRequest www = new UnityWebRequest(url, UnityWebRequest.kHttpVerbPOST); www.uploadHandler = (UploadHandler) new UploadHandlerRaw(reqBytes); www.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer(); www.SetRequestHeader("Content-Type", "application/json"); www.SetRequestHeader("Client-ID", "5kgu34ujbt2cqtm8endlhrjbkiuqgi"); Logger.Debug($"Bearer {jwt}"); www.SetRequestHeader("Authorization", $"Bearer {jwt}"); var asyncOperation = www.SendWebRequest(); while (!asyncOperation.isDone) { yield return(null); } var download = www.downloadHandler; Logger.Debug(download.text); if (www.isNetworkError || www.isHttpError) { Logger.Debug(www.error); } else { Logger.Debug("Form upload complete!"); } www.Dispose(); } }
/// <summary> /// Broadcast a message /// </summary> /// <returns> BroadcastResponse object </returns> /// <param name="request"> BroadcastRequest object</param> /// <param name='jsonRpcCallId'> /// The json rpc call identifier. This is a string generated by the client, which can be used to correlate the response to the request. Max length is 256 characters. A JSON-RPC id must be generated on a per call invocation basis. The Rogerthat platform uses the id of the call to store the call result for a certain amount of time so that if something fails during the communication, the same call (having the same JSON-RPC id) can be resent to the Rogerthat service, allowing to fetch the result, without actually executing the call again. This avoids annoying problems such as duplicate delivery of messages. /// /// You should use a different JSON-RPC id for every call you make. /// /// In case of an intermittent failure such as a network connectivity problem, you can retry the same call using the same JSON-RPC id, without running the risk of duplicate execution of your call (e.g. duplicate message delivery). /// </param> public BroadcastResponse Broadcast(BroadcastRequest request, string jsonRpcCallId) { BroadcastResponse result = new BroadcastResponse(); WireRequest(0, jsonRpcCallId, "messaging.broadcast", (writer) => { request.Write(writer, false); }, (reader) => { result.Read(reader); } ); return result; }
/// <summary> /// Broadcast a message /// </summary> /// <returns> BroadcastResponse object </returns> /// <param name="request"> BroadcastRequest object</param> public BroadcastResponse Broadcast(BroadcastRequest request) { return Broadcast(request, Guid.NewGuid().ToString()); }
public static void invokeMessageSent(BroadcastRequest request) { messageSent?.Invoke(request); }
public static void invokeMessageRecived(BroadcastRequest message) { messageReceived?.Invoke(message); }