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);
}
