public void Players_OnRemovePlayer(GenericEvent evt)
{
if (!MyConfig.Settings.Enabled)
{
return;
}
if (MyConfig.Instance.Settings.PlayerLeavingMessage.StartsWith("null"))
{
return;
}
if (debugMode)
{
Console.WriteLine($"<- Sending Disconnect Message To Discord");
}
Player player = evt.Data.DeserializedObject as Player;
if (player == null)
{
return;
}
string outMsg = MyConfig.Instance.Settings.PlayerLeavingMessage.Replace("(%PlayerName%)", player.Name).Replace("(%CurrentDateTime%)", DateTime.Now.ToString())
?? $"{player.Name} disconnected from the game server.";
var channel = MyConfig.Instance.Settings.CDCChannelID != 0
? MyConfig.Instance.Settings.CDCChannelID
: MyConfig.Instance.Settings.MainChannelID;
DiscordClient.SendMessageToChannel(channel, outMsg);
}
public void PlayerSpawnRequest(GenericEvent evnt)
{
PlayerSpawnRequest data = evnt.Data as PlayerSpawnRequest;
//Check if Permissions are Loaded
ServerInstance.Instance.PermissionManager.GetPermission(data.Sender);
}
public void SendNavigateEvent(string url, bool back, bool forward)
{
if (Initialized)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.Navigate,
GenericType = MessageLibrary.BrowserEventType.Generic,
NavigateUrl = url
};
if (back)
{
ge.Type = GenericEventType.GoBack;
}
else if (forward)
{
ge.Type = GenericEventType.GoForward;
}
EventPacket ep = new EventPacket()
{
Event = ge,
Type = MessageLibrary.BrowserEventType.Generic
};
_outCommServer.TrySend(ep, 100);
}
}
public void Arrange()
{
_event = new GenericEvent
{
Type = "TestEvent",
Payload = "{\"Data\":\"test\"}",
Id = 123
};
_eventModel = new TestEvent
{
Data = "AJVFD943igf"
};
_eventService = new Mock <IEventService>();
_eventModelFactory = new Mock <IEventModelFactory>();
_logger = new Mock <ILog>();
_eventService.Setup(x => x.GetUnprocessedGenericEvents(It.IsAny <string>()))
.ReturnsAsync(new List <GenericEvent> {
_event
});
_eventModelFactory.Setup(x => x.Create <TestEvent>(It.IsAny <string>()))
.Returns(_eventModel);
_collector = new GenericEventCollector <TestEvent>(_eventService.Object, _eventModelFactory.Object, _logger.Object);
}
public static void GenericEvent(string actionid = "", string data = "")
{
if (sessionMetricList == null)
{
sessionMetricList = new List <MetricEvent>();
}
MetricEvent newEvent = new MetricEvent();
newEvent.SetEventInfo(uuid, user, sessionID, null);
GenericEvent metricData = new GenericEvent(actionid, data);
newEvent.Timestamp(DateTime.UtcNow);
newEvent.Data(metricData);
//Keep a tally of the events in a session in the case of time race conditions to still know which event occured first
newEvent.SessionIndex(sessionMetricList.Count);
//add it to the list of events this session
sessionMetricList.Add(newEvent);
//set the last action to have the duration easily accesible for the event end
lastActionTime = newEvent.Timestamp();
//TODO: attempt to upload to database
//if fail then save
APIManager.SubmitMetrics((new MetricEvent[1] {
newEvent
}), (res) => HandleResponse(res));
sessioncount++;
}
private StatusCode DispatchControllerMethod(
RequestContext context,
MethodHandle methodHandle,
IList <Variant> inputArguments,
List <StatusCode> inputArgumentResults,
List <Variant> outputArguments)
{
SystemFunction data = methodHandle.MethodData as SystemFunction;
if (data != null)
{
this.currentData = "CALL " + data.Function + inputArguments[0].ToString();
GenericEvent e = new GenericEvent(Server.FilterManager);
e.Initialize(
null,
ObjectTypeIds.SystemEventType,
ParsedNodeId.Construct(0, "Jemima", DefaultNamespaceIndex),
"Jemima",
EventSeverity.Medium,
"A Jemima is CALL."
);
//e.Set(e.ToPath(new QualifiedName("Jackey", DefaultNamespaceIndex)), currentData);
ReportEvent(e.SourceNode, e);
return(StatusCodes.Good);
}
return(StatusCodes.BadNotImplemented);
}
public async Task <IHttpActionResult> CreateGenericEvent(GenericEvent @event)
{
await _orchestrator.CreateEvent(@event);
// 201 for list of all events
return(Created("GetSinceEvent", @event));
}
public static void InvokeIfNotNull <T1, T2, T3, T4, T5, T6>(this GenericEvent <T1, T2, T3, T4, T5, T6> genericEvent, T1 args1, T2 args2, T3 args3, T4 args4, T5 args5, T6 args6)
{
if (genericEvent != null)
{
genericEvent(args1, args2, args3, args4, args5, args6);
}
}
public override bool Notify(GenericEvent ev) => ev.Type == EventType.ProgrammingTimerStart || ev.Type == EventType.ProgrammingTimerStop || ev.Type == EventType.TimeElapsed || ev.Type == EventType.ChangeRegister || ev.Type == EventType.RandomCardDistribution || ev.Type == EventType.ClearRegister;
public static void InvokeIfNotNull <T1, T2, T3, T4>(this GenericEvent <T1, T2, T3, T4> genericEvent, T1 args1, T2 args2, T3 args3, T4 args4)
{
if (genericEvent != null)
{
genericEvent(args1, args2, args3, args4);
}
}
public static void InvokeIfNotNull <T1, T2>(this GenericEvent <T1, T2> genericEvent, T1 args1, T2 args2)
{
if (genericEvent != null)
{
genericEvent(args1, args2);
}
}
public static void InvokeIfNotNull <T1>(this GenericEvent <T1> genericEvent, T1 args1)
{
if (genericEvent != null)
{
genericEvent(args1);
}
}
public void SendNavigateEvent(string url, bool back, bool forward)
{
if (Initialized)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.Navigate,
GenericType = MessageLibrary.BrowserEventType.Generic,
NavigateUrl = url
};
if (back)
{
ge.Type = GenericEventType.GoBack;
}
else if (forward)
{
ge.Type = GenericEventType.GoForward;
}
EventPacket ep = new EventPacket()
{
Event = ge,
Type = MessageLibrary.BrowserEventType.Generic
};
/*MemoryStream mstr = new MemoryStream();
* BinaryFormatter bf = new BinaryFormatter();
* bf.Serialize(mstr, ep);
* byte[] b = mstr.GetBuffer();
* _outCommServer.WriteBytes(b);*/
_outCommServer.WriteMessage(ep);
}
}
public RawGenericInputReport(PresentationSource inputSource,
GenericEvent genericEvent, UIElement destTarget)
: base(inputSource, genericEvent.Time)
{
InternalEvent = genericEvent;
Target = destTarget;
}
public void SendNavigateEvent(string url, bool back, bool forward)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.Navigate,
GenericType = BrowserEventType.Generic,
NavigateUrl = url
};
if (back)
{
ge.Type = GenericEventType.GoBack;
}
else if (forward)
{
ge.Type = GenericEventType.GoForward;
}
EventPacket ep = new EventPacket()
{
Event = ge,
Type = BrowserEventType.Generic
};
MemoryStream mstr = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mstr, ep);
byte[] b = mstr.GetBuffer();
lock (_clientSocket.GetStream())
{
_clientSocket.GetStream().Write(b, 0, b.Length);
}
}
public async Task <IActionResult> PutGenericEvent([FromRoute] int id, [FromBody] GenericEvent genericEvent)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != genericEvent.Id)
{
return(BadRequest());
}
_context.Entry(genericEvent).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GenericEventExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
protected virtual void OnDestroy()
{
if (persistent)
{
GenericEvent.RemoveListener(this, Key);
}
}
public void SendNavigateEvent(string url, bool back, bool forward)
{
if (Initialized)
{
GenericEvent ge = new GenericEvent {
Type = GenericEventType.Navigate,
GenericType = BrowserEventType.Generic,
StringContent = RedirectLocalhost(url),
AdditionalStringContent = FilteredBundleName()
};
if (back)
{
ge.Type = GenericEventType.GoBack;
}
else if (forward)
{
ge.Type = GenericEventType.GoForward;
}
EventPacket ep = new EventPacket {
Event = ge,
Type = BrowserEventType.Generic
};
_outCommServer.TrySend(ep, 1000);
}
}
protected virtual void OnDisable()
{
if (!persistent)
{
GenericEvent.RemoveListener(this, Key);
}
}
protected virtual void Awake()
{
if (persistent)
{
GenericEvent.AddListener(this, Key);
}
}
public void StartListening <T>(string eventName, UnityAction <T> listener)
{
Dictionary <string, GenericEvent <T> > typeDictionary = null;
object baseDict = null;
if (eventDictionaryType.TryGetValue(typeof(T), out baseDict))
{
typeDictionary = baseDict as Dictionary <string, GenericEvent <T> >;
}
else
{
typeDictionary = new Dictionary <string, GenericEvent <T> >();
eventDictionaryType.Add(typeof(T), typeDictionary);
}
GenericEvent <T> thisEvent = null;
if (typeDictionary.TryGetValue(eventName, out thisEvent))
{
thisEvent.AddListener(listener);
}
else
{
thisEvent = new GenericEvent <T>();
thisEvent.AddListener(listener);
typeDictionary.Add(eventName, thisEvent);
}
}
protected virtual void OnEnable()
{
if (!persistent)
{
GenericEvent.AddListener(this, Key);
}
}
public void SendNavigateEvent(string url, bool back, bool forward)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.Navigate,
GenericType = BrowserEventType.Generic,
StringContent = url
};
if (back)
{
ge.Type = GenericEventType.GoBack;
}
else if (forward)
{
ge.Type = GenericEventType.GoForward;
}
EventPacket ep = new EventPacket()
{
Event = ge,
Type = BrowserEventType.Generic
};
MemoryStream mstr = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mstr, ep);
byte[] b = mstr.GetBuffer();
//
_outCommServer.WriteBytes(b);
// MessageBox.Show(_sendEvents.Count.ToString());
}
public override OperationResponse Handle(OperationRequest request, SendParameters sendParameters)
{
log.InfoFormat("push send operation received...");
SendPushToPlayersOperationRequest operation = new SendPushToPlayersOperationRequest(peer.Protocol, request);
if (!operation.IsValid)
{
return(InvalidParametersOperationResponse(Common.SelectCharacterOperationCode.SendPushToPlayers));
}
Hashtable pushInfo = new Hashtable {
{ (int)SPC.Type, operation.pushType },
{ (int)SPC.Body, operation.body },
{ (int)SPC.Title, operation.title }
};
GenericEvent genEvt = new GenericEvent {
subCode = (int)SelectCharacterGenericEventSubCode.Push,
data = pushInfo
};
application.Clients.SendGenericEvent(genEvt);
return(new OperationResponse((byte)SelectCharacterOperationCode.SendPushToPlayers));
}
private void PostProcessInput(object sender, ProcessInputEventArgs e)
{
InputReportEventArgs input = e.StagingItem.Input as InputReportEventArgs;
if (input != null && input.RoutedEvent == InputManager.InputReportEvent)
{
RawGenericInputReport report = input.Report as RawGenericInputReport;
if (report != null)
{
if (!e.StagingItem.Input.Handled)
{
GenericEvent ge = (GenericEvent)report.InternalEvent;
GenericEventArgs args = new GenericEventArgs(
this,
report.InternalEvent);
args.RoutedEvent = GenericEvents.GenericStandardEvent;
if (report.Target != null)
{
args.Source = report.Target;
}
e.PushInput(args, e.StagingItem);
}
}
}
}
public void SendExecuteJSEvent(string js)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.ExecuteJS,
GenericType = BrowserEventType.Generic,
JsCode = js
};
EventPacket ep = new EventPacket()
{
Event = ge,
Type = BrowserEventType.Generic
};
MemoryStream mstr = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mstr, ep);
byte[] b = mstr.GetBuffer();
lock (_clientSocket.GetStream())
{
_clientSocket.GetStream().Write(b, 0, b.Length);
}
}
public void SendPing()
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.Navigate, //could be any
GenericType = BrowserEventType.Ping,
};
EventPacket ep = new EventPacket()
{
Event = ge,
Type = BrowserEventType.Ping
};
MemoryStream mstr = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mstr, ep);
byte[] b = mstr.GetBuffer();
//
lock (_clientSocket.GetStream())
{
_clientSocket.GetStream().Write(b, 0, b.Length);
}
}
public void SendQueryResponse(string response)
{
GenericEvent ge = new GenericEvent()
{
Type = GenericEventType.JSQueryResponse,
GenericType = BrowserEventType.Generic,
JsQueryResponse = response
};
EventPacket ep = new EventPacket()
{
Event = ge,
Type = BrowserEventType.Generic
};
MemoryStream mstr = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mstr, ep);
byte[] b = mstr.GetBuffer();
//
lock (_clientSocket.GetStream())
{
_clientSocket.GetStream().Write(b, 0, b.Length);
}
}
public static void InvokeIfNotNull(this GenericEvent genericEvent)
{
if (genericEvent != null)
{
genericEvent();
}
}
public bool OnEvent(BaseEvent baseEvent)
{
if (baseEvent is TouchEvent)
{
TouchEvent e = (TouchEvent)baseEvent;
switch (e.EventMessage)
{
case (byte)TouchMessages.Down: HandleTouchDownEvent(e); break;
case (byte)TouchMessages.Move: HandleTouchMoveEvent(e); break;
case (byte)TouchMessages.Up: HandleTouchUpEvent(e); break;
}
}
else if (baseEvent is GenericEvent)
{
GenericEvent e = (GenericEvent)baseEvent;
if (e.EventCategory == (byte)EventCategory.Gesture)
{
TouchGestureEventArgs args = new TouchGestureEventArgs((TouchGesture)e.EventMessage, e.X, e.Y, (ushort)e.EventData, e.Time);
switch (args.Gesture)
{
case TouchGesture.Begin: NotifyTouchGestureStarted(args); break;
case TouchGesture.End: NotifyTouchGestureEnded(args); break;
default: NotifyTouchGestureChanged(args); break;
}
}
}
return(true);
}
public TexturedButton(Sprite sprite, Vector2 centerPosition, GenericEvent clicked)
: this(sprite, new RectangleF(centerPosition.X - sprite.Width / 2f * sprite.Scale.X, centerPosition.Y - sprite.Height / 2f * sprite.Scale.Y, sprite.Width * sprite.Scale.Y, sprite.Height * sprite.Scale.Y))
{
this.Click += clicked;
}
public TextButton(string text, Vector2 position, GenericEvent<TextButton> clickFunction)
: this(text, position)
{
this.Click += () => clickFunction(this);
}
public TextButton(string text, Vector2 position, GenericEvent clickFunction)
: this(text, position)
{
this.Click += clickFunction;
}
private async Task<IList<GenericEvent>> PullEvents()
{
Log.Info("Pulling events");
var myEvts = new DbCollection<GenericEvent>();
try
{
var evts = await Service.Events.List(_settings.CalendarId).ExecuteAsync();
foreach (var evt in evts.Items)
{
var iCalUid = StringHelper.GetString(StringHelper.GoogleBase32.FromBaseString(evt.Id));
var myEvt = new GenericEvent( id: iCalUid,
summary: evt.Summary,
description: evt.Description,
location: new GenericLocation {Name = evt.Location});
// Organizer
if (evt.Organizer != null)
{
myEvt.Organizer = new GenericPerson
{
Email = evt.Organizer.Email,
Name = evt.Organizer.DisplayName
};
}
// Creator
if (evt.Creator != null)
{
myEvt.Creator = new GenericPerson
{
Email = evt.Creator.Email,
Name = evt.Creator.DisplayName
};
}
// Start
if (evt.Start != null)
{
myEvt.Start = evt.Start.DateTime;
}
// End
if (evt.End != null)
{
myEvt.End = evt.End.DateTime;
}
// Creation date
if (evt.Created.HasValue)
{
myEvt.Created = evt.Created;
}
// Recurrence
if (evt.Recurrence != null)
{
myEvt.Recurrence = new GoogleRecurrence();
((GoogleRecurrence) myEvt.Recurrence).Parse(evt.Recurrence[0]);
//warning: this only parses one line inside Recurrence...
}
// Attendees
if (evt.Attendees != null)
{
myEvt.Attendees = new List<GenericAttendee>();
foreach (var attendee in evt.Attendees)
{
ResponseStatus r;
switch (attendee.ResponseStatus)
{
case "accepted":
r = ResponseStatus.Accepted;
break;
case "tentative":
r = ResponseStatus.Tentative;
break;
case "needsAction":
r = ResponseStatus.NotResponded;
break;
case "declined":
r = ResponseStatus.Declined;
break;
default:
r = ResponseStatus.None;
break;
}
myEvt.Attendees.Add(
new GenericAttendee
{
Email = attendee.Email,
Name = attendee.DisplayName,
Response = r
}
);
}
}
myEvts.Add(myEvt);
}
}
catch (Exception ex)
{
Log.Error("Exception", ex);
}
return myEvts;
}
public PushException(string message, GenericEvent failedEvent)
: base(message)
{
FailedEvent = failedEvent;
}
public ScrollerTextureButton(Sprite sprite, Vector2 position, Scroller scroller, GenericEvent clickFunction)
: base(sprite, position, clickFunction)
{
_realVerticalPosition = position.Y;
_scroller = scroller;
}
public override ICalendar Pull(DateTime from, DateTime to)
{
Log.Info(String.Format("Pulling calendar from outlook, from[{0}] to [{1}]", from, to));
var myCalendar = new GenericCalendar
{
Events = new DbCollection<GenericEvent>()
};
try
{
myCalendar.Id = CalendarFolder.EntryID;
myCalendar.Name = CalendarFolder.Name;
#if !OLD_OFFICE_ASSEMBLY
myCalendar.Creator = new GenericPerson
{
Email = CalendarFolder.Store.DisplayName
};
#endif
//
var items = CalendarFolder.Items;
items.Sort("[Start]");
var filter = "[Start] >= '"
+ from.ToString("g")
+ "' AND [End] <= '"
+ to.ToString("g") + "'";
Log.Debug(String.Format("Filter string [{0}]", filter));
items = items.Restrict(filter);
//
foreach (AppointmentItem evt in items)
{
//
var myEvt = new GenericEvent( id: evt.EntryID,
summary: evt.Subject,
description: evt.Body,
location: new GenericLocation { Name = evt.Location });
// Start
myEvt.Start = evt.Start;
// End
if (!evt.AllDayEvent)
{
myEvt.End = evt.End;
}
//
#if !OLD_OFFICE_ASSEMBLY // this only works with office 2010
// Creator and organizer are the same person.
// Creator
myEvt.Creator = new GenericPerson
{
Email = evt.GetOrganizer().Address,
Name = evt.GetOrganizer().Name
};
// Organizer
myEvt.Organizer = new GenericPerson
{
Email = evt.GetOrganizer().Address,
Name = evt.GetOrganizer().Name
};
#endif
// Attendees
myEvt.Attendees = ExtractRecipientInfos(evt);
// Recurrence
if (evt.IsRecurring)
{
myEvt.Recurrence = new OutlookRecurrence();
((OutlookRecurrence)myEvt.Recurrence).Parse(evt.GetRecurrencePattern());
}
// add it to calendar events.
myCalendar.Events.Add(myEvt);
}
}
catch (System.Exception ex)
{
Log.Error("Exception", ex);
}
LastCalendar = myCalendar;
return myCalendar;
}
public ConversationPiece(int speaker, string text, GenericEvent onFinished = null)
{
this.SpeakerIndex = speaker;
this.Text = text;
this.OnFinished = onFinished;
}
public ScrollerButton(string text, Vector2 position, Scroller scroller, GenericEvent clickFunction)
: base(text, position, clickFunction)
{
_realVerticalPosition = position.Y;
_scroller = scroller;
}
