void OnTestWithData(EventPayload data)
{
if (TestCase.DEBUG_MESSAGE_IN_LISTENERS)
{
Debug.Log("Event : " + EventManager.CurrentEvent + " | Data : " + data.Get <string>("Text"));
}
}
public void OnUpdateFrame(EventPayload payload)
{
if (payload.ContentType != "Float")
{
return;
}
List <Glop> garbageCollection = new List <Glop>();
foreach (Glop g in _contents.Values)
{
if (g.Garbage)
{
garbageCollection.Add(g);
}
else
{
g.Update((float)payload.GetContent());
}
}
if (garbageCollection.Count > 0)
{
foreach (Glop g in garbageCollection)
{
_contents.Remove(g.Id);
}
}
}
public void ReceiveEvent(TofuEvent evnt, EventPayload payload)
{
if (_boundListeners == null)
{
return;
}
if (!_boundListeners.ContainsKey(evnt))
{
Debug.Log("Expected event " + evnt + " but found no action bound");
}
foreach (Action <EventPayload> action in _boundListeners[evnt])
{
action.Invoke(payload);
}
_listenersToUnbind = new Dictionary <TofuEvent, Action <EventPayload> >();
foreach (KeyValuePair <TofuEvent, Action <EventPayload> > kvp in _listenersToUnbind)
{
UnbindListener(kvp.Key, kvp.Value, EventContext);
}
_listenersToUnbind = null;
}
private void ProcessDispatch(EventPayload response)
{
if (response.Command != Command.Dispatch)
{
return;
}
if (!response.Event.HasValue)
{
return;
}
switch (response.Event.Value)
{
//We are to join the server
case ServerEvent.ActivitySpectate:
var spectate = response.GetObject <SpectateMessage>();
EnqueueMessage(spectate);
break;
case ServerEvent.ActivityJoin:
var join = response.GetObject <JoinMessage>();
EnqueueMessage(join);
break;
case ServerEvent.ActivityJoinRequest:
var request = response.GetObject <JoinRequestMessage>();
EnqueueMessage(request);
break;
//Unkown dispatch event received. We should just ignore it.
default:
Logger.Warning("Ignoring {0}", response.Event.Value);
break;
}
}
public void TestPayloadNullContentAccepted()
{
EventPayload payload = new EventPayload("null", null);
Assert.NotNull(payload);
Assert.Null(payload.GetContent());
}
public async Task <IActionResult> Post([FromBody] EventPayload payload)
{
if (payload == null)
{
_logger.LogError("Payload is null");
return(BadRequest());
}
try
{
var driver = GetDriver(payload.DriverId);
if (driver == null)
{
_logger.LogError($"Not found driver with id: { payload.DriverId }");
return(BadRequest());
}
await AddLoginEvent(driver.Id, payload.EventTimestamp);
return(StatusCode((int)HttpStatusCode.Created));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(BadRequest());
}
}
void OnTestWithDataForEmitter(EventPayload data)
{
if (TestCase.DEBUG_MESSAGE_IN_LISTENERS)
{
Debug.Log("Event : " + EventManager.CurrentEvent + " | Emitter triggered the event. Data : " + data.Get <string>("Text"));
}
}
private void HandleGlopsDeserialized(EventPayload payload)
{
if (payload.ContentType != "Null")
{
return;
}
ReinitializeContents();
}
public void TestPayloadConstructs()
{
EventPayload payload = new EventPayload("string", "Test");
Assert.NotNull(payload);
Assert.AreEqual(payload.GetContent(), "Test");
Assert.AreEqual("string", payload.ContentType);
}
public void TestPayloadGetContentDynamic()
{
EventPayload payload = new EventPayload("integer", 4);
EventPayload payloadFloat = new EventPayload("float", 2.3f);
Assert.AreEqual(2.3f, payloadFloat.GetContent());
Assert.AreEqual(4, payload.GetContent());
}
public async Task <EventPayload> NotifySubscribersAsync(EventPayload eventPayload)
{
eventPayload.Response = await httpClient.GetStringAsync(eventPayload.ServiceUrl);
// read memory storage
return(eventPayload);
}
public IEnumerable <EventPayload> Fetch()
{
var copied = new EventPayload[Items.Count];
Items.CopyTo(copied);
Items.Clear();
return(copied);
}
public IPayload PreparePayload(long nonce)
{
EventPayload eventPayload = new EventPayload(nonce);
eventPayload.Command = this.IsUnsubscribe ? Command.Unsubscribe : Command.Subscribe;
eventPayload.Event = new ServerEvent?(this.Event);
return((IPayload)eventPayload);
}
public void TestInvalidAndUnregisteredTypes()
{
EventPayload unregisteredType = new EventPayload("Boolean", true);
EventPayload invalidType = new EventPayload("String", 2);
Assert.False(_payloadLibrary.ValidatePayload(unregisteredType));
Assert.False(_payloadLibrary.ValidatePayload(invalidType));
}
/// <summary>
/// Handles an event payload asynchronously.
/// </summary>
/// <param name="payload">the payload</param>
/// <returns>a task that represents the asynchronous operation</returns>
protected virtual async Task OnEventReceived(EventPayload payload)
{
if (!Players.TryGetValue(payload.GuildId, out var player))
{
return;
}
// a track ended
if (payload is TrackEndEvent trackEndEvent)
{
var args = new TrackEndEventArgs(player,
trackEndEvent.TrackIdentifier,
trackEndEvent.Reason);
await Task.WhenAll(OnTrackEndAsync(args),
player.OnTrackEndAsync(args));
}
// an exception occurred while playing a track
if (payload is TrackExceptionEvent trackExceptionEvent)
{
var args = new TrackExceptionEventArgs(player,
trackExceptionEvent.TrackIdentifier,
trackExceptionEvent.Error);
await Task.WhenAll(OnTrackExceptionAsync(args),
player.OnTrackExceptionAsync(args));
}
// a track got stuck
if (payload is TrackStuckEvent trackStuckEvent)
{
var args = new TrackStuckEventArgs(player,
trackStuckEvent.TrackIdentifier,
trackStuckEvent.Threshold);
await Task.WhenAll(OnTrackStuckAsync(args),
player.OnTrackStuckAsync(args));
}
// the voice web socket was closed
if (payload is WebSocketClosedEvent webSocketClosedEvent)
{
await player.DisconnectAsync(PlayerDisconnectCause.WebSocketClosed);
Players.Remove(payload.GuildId);
player.Dispose();
Logger?.Log(this, string.Format("Voice WebSocket was closed for player: {0}" +
"\nClose Code: {1} ({2}, Reason: {3}, By Remote: {4}",
payload.GuildId, webSocketClosedEvent.CloseCode,
(int)webSocketClosedEvent.CloseCode, webSocketClosedEvent.Reason,
webSocketClosedEvent.ByRemote ? "Yes" : "No"),
webSocketClosedEvent.ByRemote ? LogLevel.Warning : LogLevel.Debug);
}
}
public void DummyEventAction(EventPayload payload)
{
DummyActionsCalled++;
if (payload.ContentType == "Float")
{
float contentFloat = ((float)payload.GetContent());
DummyActionsCapturedFloats += contentFloat;
}
}
public void Zarfed(EventPayload eP)
{
if (eP.ContentType == "String")
{
string value = eP.GetContent();
LastZarfPayload = value;
}
ZarfCalled++;
}
void UpdateTime(float seconds)
{
if (EventContext == null)
{
return;
}
EventPayload deltaTimePayload = new EventPayload("Float", seconds);
EventContext.PreUpdate();
EventContext.TriggerEvent(EventKey.FrameUpdate, deltaTimePayload);
}
public async Task Append(EventPayload evnt)
{
var json = JsonConvert.SerializeObject(evnt.Data);
_eventStream.Add(evnt.Subject,
evnt.Aggregate,
evnt.Kind,
json,
evnt.Timestamp);
await _coordinatorApi.Publish(evnt);
}
public void TestRegisteredTypes()
{
EventPayload floatPayload = new EventPayload("Float", 1.2f);
EventPayload intPayload = new EventPayload("Integer", 1);
EventPayload stringPayload = new EventPayload("String", "Test");
EventPayload gameObjectPayload = new EventPayload("GameObject", new GameObject("Test"));
Assert.True(_payloadLibrary.ValidatePayload(floatPayload));
Assert.True(_payloadLibrary.ValidatePayload(intPayload));
Assert.True(_payloadLibrary.ValidatePayload(stringPayload));
Assert.True(_payloadLibrary.ValidatePayload(gameObjectPayload));
}
/// <inheritdoc/>
public async Task <object> ReceiveAsync(IWebHookExecutionContext context)
{
EventPayload meta = JsonConvert.DeserializeObject <EventPayload>(context.Payload.ToString());
var handlerType = Options.Handlers[meta.EventType];
using (var scope = ServiceScopeFactory.CreateScope())
{
var receiver = (IAzureDevOpsHandler)scope.ServiceProvider.GetRequiredService(handlerType);
return(await receiver.HandleAsync(context));
}
}
protected void UnitDestroyed(EventPayload eventPayload)
{
if (eventPayload.ContentType != "Agent")
{
return;
}
Agent agent = eventPayload.GetContent();
if (agent.Id == Renderable.Id)
{
UnbindListener(EventContext.GetEvent(EventKey.UnitDies), UnitDestroyed, EventContext);
ToDestroy = true;
}
}
void OnFrameUpdate(EventPayload payload)
{
if (results.Count > 0)
{
int itemsInQueue = results.Count;
lock (results)
{
for (int i = 0; i < itemsInQueue; i++)
{
PathResult result = results.Dequeue();
result.Callback(result.Path, result.Success);
}
}
}
}
private State ApplyEvent(State state, EventPayload payload)
{
switch (payload)
{
case AuctionCreated auctionCreated:
return(CreatedState.Create(
auctionCreated.Auction.EndTime,
auctionCreated.Auction.StartingPrice));
case BidPlaced bidPlaced:
return(CreatedState.WithHighestBid(state as CreatedState, bidPlaced.Bid.Amount));
default:
throw new Exception("Unknown event type");
}
}
private void OnReceiveUpdate(EventPayload payload)
{
if (payload.ContentType != PayloadType)
{
return;
}
string value = HandleType(payload);
if (_text != null)
{
_text.text = value;
}
else if (_textMesh != null)
{
_textMesh.text = value;
}
}
void ProcessEvent(EventPayload a_event)
{
if (a_event.Event.HasValue && a_event.Event == EventPayload.e_ServerEvent.Error)
{
ErrorMessage error = a_event.GetObject <ErrorMessage>();
InternalConsole.Error(string.Format("Discord responded with error: ({0}) {1}", error.ErrorCode, error.Message));
EnqueueMessage(error);
}
if (m_state == e_RPCState.Connecting)
{
if (a_event.Command == e_Command.Dispatch && a_event.Event.HasValue && a_event.Event.Value == EventPayload.e_ServerEvent.Ready)
{
m_state = e_RPCState.Connected;
ReadyMessage ready = a_event.GetObject <ReadyMessage>();
m_config = ready.Configuration;
User user = ready.User;
user.Configuration = ready.Configuration;
ready.User = user;
m_user = user;
EnqueueMessage(ready);
return;
}
}
// TODO: Implement Connected Commands
if (m_state == e_RPCState.Connected)
{
switch (a_event.Command)
{
case e_Command.Dispatch:
{
break;
}
}
}
}
public static bool TryParseResponse(string json, out RichPresence response)
{
try
{
EventPayload eventPayload = JsonConvert.DeserializeObject <EventPayload>(json);
if (eventPayload != null)
{
response = (RichPresence)eventPayload.GetObject <RichPresenceResponse>();
return(true);
}
}
catch (Exception ex)
{
}
response = (RichPresence)null;
return(false);
}
private void OnReceiveUpdate(EventPayload payload)
{
if (payload.ContentType != "ResourceStateEventPayload")
{
return;
}
ResourceStateEventPayload resourceState = payload.GetContent();
if (resourceState.Target.Id != OwnerGlopId)
{
return;
}
float percent = (float)resourceState.Amount / resourceState.Max;
Rerender(percent);
}
public void ReceiveEvent(TofuEvent evnt, EventPayload payload)
{
FlushListeners();
if (_boundListeners == null)
{
return;
}
if (!_boundListeners.ContainsKey(evnt))
{
Debug.Log("Expected event " + evnt + " but found no action bound");
}
foreach (Action <EventPayload> action in _boundListeners[evnt])
{
action.Invoke(payload);
}
FlushListeners();
}
public ActionResult Remove([System.Web.Http.FromBody] EventPayload data)
{
// TODO: move data validation
if (!data.IsValid())
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "invalid data"));
}
try
{
facetService.Add(data.EventIdFormatted, FacetIDs.RegisteredEvents);
}
catch (Exception ex)
{
Log.Error($"Unable to remove value '{data.EventId}' to contact's '${FacetIDs.RegisteredEvents}' facet ", ex, this);
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, ex.Message));
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
