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