/// <summary>
/// Sends an event into the instance.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="event">The <see cref="JsonEvent"/> instance containing the event data.</param>
public void SendJsonEvent(string instanceId, JsonEvent @event)
{
try {
var instance = GetInstanceOrFault(instanceId);
var fabricator = instance.SchemaFabricator;
var eventBytes = System.Text.Encoding.UTF8.GetBytes(@event.EventData);
var dictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
eventBytes, 0, eventBytes.Length, new XmlDictionaryReaderQuotas());
var fabricatorType = fabricator.GetType(@event.EventType);
if (fabricatorType != null)
{
var serializer = new DataContractJsonSerializer(fabricatorType);
var trueEntity = serializer.ReadObject(dictionaryReader);
instance.SendEvent(trueEntity);
}
else
{
var dictionaryDocument = XDocument.Load(dictionaryReader);
dictionaryDocument.Root.Name = @event.EventType;
instance.SendEvent(dictionaryDocument.Root);
}
}
catch (EPException e) {
Log.Warn("SendJsonEvent: BadRequest returned: {0}", e.Message);
throw new WebFaultException <string>(e.Message, HttpStatusCode.BadRequest);
}
}
public ActionResult <IEnumerable <JsonEvent> > Post(string cameraId, DateTime beginPeriod, DateTime endPeriod, Guid lastEvent, string movingType)
{
const int quantityReceivedEvents = 10;
var listEventsForCamera = dbContext.FrameParameters.Where(item => item.Parameters.Name == "CameraId" && item.Value == cameraId).Select(item => item.Frames.EventId).Distinct();
var eventList = new List <JsonEvent>();
var nextPageEvents = new List <JsonEvent>();
foreach (var eventForCamera in listEventsForCamera)
{
var transferEvent = new JsonEvent();
transferEvent.EventId = eventForCamera;
transferEvent.EventStartTime = dbContext.Frames.Where(item => item.EventId == eventForCamera).Min(item => item.Timestamp);
transferEvent.EventEndTime = dbContext.Frames.Where(item => item.EventId == eventForCamera).Max(item => item.Timestamp);
transferEvent.NumberImages =
dbContext.Frames.Where(item => item.EventId == eventForCamera).Distinct().Count();
if (beginPeriod != DateTime.MinValue && endPeriod != DateTime.MinValue)
{
if (transferEvent.EventStartTime >= beginPeriod && transferEvent.EventEndTime <= endPeriod)
{
eventList.Add(transferEvent);
}
}
else
{
eventList.Add(transferEvent);
}
}
eventList = eventList.OrderByDescending(item => item.EventStartTime).ToList();
if (lastEvent != Guid.Empty)
{
var indexLastEvent = eventList.FindIndex(item => item.EventId == lastEvent);
if (movingType == "Next")
{
nextPageEvents = eventList.GetRange(++indexLastEvent, Math.Min(quantityReceivedEvents, eventList.Count - indexLastEvent));
if (nextPageEvents.Count == 0)
{
nextPageEvents = eventList.Take(quantityReceivedEvents).ToList();
}
}
else if (movingType == "Back")
{
nextPageEvents = eventList.Skip(--indexLastEvent - quantityReceivedEvents).Take(quantityReceivedEvents).ToList();
}
}
else
{
nextPageEvents = eventList.Take(quantityReceivedEvents).ToList();
}
return(nextPageEvents);
}
/**
* Method that determines what kind of event happened. Used for when the Slack
* information has two events with the same name but are slightly different.
* For example, a message event and a reply.
*
* @return string - The name of the event that occurred.
*/
public static string DiagnoseEvent(JsonEvent slackEvent)
{
if (slackEvent == null || slackEvent.Event == null || slackEvent.Event.Type == null)
{
return(ControllerConstants.NOT_EVENT_MESSAGE);
}
if (slackEvent.Event.Type == SlackConstants.Events.MESSAGE_SENT)
{
return(slackEvent.Event.Thread_ts == null ? SlackConstants.Events.MESSAGE_SENT : SlackConstants.Events.REPLY_SENT);
}
return(slackEvent.Event.Type);
}
/**
* The only available method to client code, a list of handlers for different events is given and
* this method will find the proper one for the given event and call its Handle() method.
*
* This is pretty much a Chain of Command design pattern, allowing one method call (this one)
* to be used to handle any event. The only new work for a new event is to make the child class of this one
* implement Handle().
*
* @param handlers - A List of EventHandlers, this list is searched for the proper handler for the given event.
* @param jsonEvent - The Slack JSON Event object.
* @return Task<bool> - Signifies if the event was handled properly.
*/
public static async Task <bool> HandleEvent(List <EventHandler> handlers, JsonEvent jsonEvent)
{
//check inputs are ok
if (jsonEvent == null || handlers == null)
{
return(false);
}
//search for suitable handler for event, if find one have it handle event
foreach (EventHandler handler in handlers)
{
if (handler.CanHandle(jsonEvent))
{
return(await handler.Handle(jsonEvent.Event)); //only ever use one handler for an event
}
}
return(false); //no suitable handler found, event not handled
}
/// <summary>
/// Send an event represented by a plain object to the event stream processing
/// runtime.
/// </summary>
/// <param name="obj">is the event to sent to the runtime</param>
public void SendEvent(object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
// register the type just incase it hasn't been
_administrator.RegisterType(obj.GetType());
var eventPublisher = GetEventPublisher();
var serialized = SerializationFabric.Serialize(obj);
var eventArgs = new JsonEvent(obj.GetType().FullName, serialized);
var eventElement = new XElement(
"json",
new XElement("type", new XCData(eventArgs.EventType)),
new XElement("data", new XCData(eventArgs.EventData)));
eventPublisher.SendEvent(eventElement);
}
public static async Task <EventDetail> AddEvent(string name, DateTime date, string url, string location, string description, string creatorid)
{
var token = await AppToken();
if (token == null)
{
return(null);
}
var client = new RestClient(RaceDayConfiguration.Instance.APIUrl);
client.AddHeader("Authorization", $"Bearer {token}");
var eventInfo = new JsonEvent
{
Name = name,
Date = date,
Url = url,
Location = location,
Description = description,
CreatorId = creatorid
};
var result = await client.PostApi <EventDetail>(COMMAND_EVENT, eventInfo, HttpStatusCode.Created);
if (client.StatusCode == HttpStatusCode.Unauthorized)
{
token = await Authorize();
if (token != null)
{
client.ClearHeaders();
client.AddHeader("Authorization", $"Bearer {token}");
result = await client.PostApi <EventDetail>(COMMAND_EVENT, eventInfo, HttpStatusCode.Created);
}
}
return(result);
}
public override object DeserializeEvent(JsonEvent eventJson)
{
return(_serializer.GetEvent(eventJson));
}
private void CreateCaseNote(DateTime time, JsonEvent arg2)
{
var caseNoteData = JsonConvert.DeserializeObject<CaseNoteData>(arg2.Value);
_caseRepository.CreateCaseNote(time, caseNoteData);
}
private void ClearCases(DateTime time, JsonEvent arg2)
{
_caseRepository.Clear();
}
/// <summary>
/// Sends an event into the instance.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="event">The <see cref="JsonEvent"/> instance containing the event data.</param>
public void SendJsonEvent(string instanceId, JsonEvent @event)
{
try {
var instance = GetInstanceOrFault(instanceId);
var fabricator = instance.SchemaFabricator;
var eventBytes = System.Text.Encoding.UTF8.GetBytes(@event.EventData);
var dictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
eventBytes, 0, eventBytes.Length, new XmlDictionaryReaderQuotas());
var fabricatorType = fabricator.GetType(@event.EventType);
if (fabricatorType != null)
{
var serializer = new DataContractJsonSerializer(fabricatorType);
var trueEntity = serializer.ReadObject(dictionaryReader);
instance.SendEvent(trueEntity);
}
else
{
var dictionaryDocument = XDocument.Load(dictionaryReader);
dictionaryDocument.Root.Name = @event.EventType;
instance.SendEvent(dictionaryDocument.Root);
}
}
catch (EPException e) {
Log.Warn("SendJsonEvent: BadRequest returned: {0}", e.Message);
throw new WebFaultException<string>(e.Message, HttpStatusCode.BadRequest);
}
}
private void RespondToAlarm(DateTime time, JsonEvent arg2)
{
var response = JsonConvert.DeserializeObject<ResponseData>(arg2.Value);
_alarmRepository.RespondToAlarm(response.NormalizedId, response.Response, time, response.UserId, response.AlarmStatus, response.AlarmState);
}
private void ClearAlarms(DateTime time, JsonEvent arg2)
{
_alarmRepository.Clear();
}
private void AddCannedResponseText(DateTime time, JsonEvent arg2)
{
_buildingSecurityClient.AddCannedResponseText(arg2.Value);
}
private void UpdateCase(DateTime arg1, JsonEvent arg2)
{
var caseUpdate= JsonConvert.DeserializeObject<CaseData>(arg2.Value);
_caseRepository.UpdateCase(caseUpdate);
}
private void ClearCaseNotes(DateTime time, JsonEvent arg2)
{
var caseId = JsonConvert.DeserializeObject<string>(arg2.Value);
_caseRepository.ClearCaseNotes(caseId);
}
/**
* Method that determines if this instance of EventHandler can handle the event passed in.
* Used so that HandleEvent() can determine which handler can handle the given event.
*
* @param jsonEvent - The JSON sent by the Slack Events API. Used to determine the type of event.
* @return bool - Signifies if the event can be handled by this handler.
*/
protected bool CanHandle(JsonEvent jsonEvent)
{
return(_eventToHandle == GetEvent.DiagnoseEvent(jsonEvent));
}
private void CreateAlarm(DateTime time, JsonEvent arg2)
{
var alarm = JsonConvert.DeserializeObject<AlarmData>(arg2.Value);
_alarmRepository.CreateAlarm(alarm);
}
