public HttpResponseMessage Put(EventMessageModel model)
{
int id = UoW.EventMessageRepository.UpdateEventmessage(new EventMessage
{
Code = model.Code,
Id = model.Id,
Message = model.Message
});
return(Request.CreateResponse(HttpStatusCode.OK, id));
}
public async Task <IActionResult> CreateEventBatch()
{
var eventBatch = new EventMessageModel[]
{
new EventMessageModel("Batch Event One Created"),
new EventMessageModel("Batch Event Two Created"),
new EventMessageModel("Batch Event Three Created")
, new EventMessageModel("Batch Event Four Created")
};
await _eventHubManager.SendEventsAsync(eventBatch)
.ConfigureAwait(false);
return(RedirectToAction("Create"));
}
public async Task <IActionResult> Index([FromBody] EventMessageModel model)
{
// Return challenge from slack if this is a challenge request
if (model?.Challenge != null)
{
return(Ok(model.Challenge));
}
// Otherwise do word count //
await new WordRanker(new WordDataHandler(), _logger).Collect(model?.Event.Text);
// logging information as json string //
_logger.LogInformation(JsonConvert.SerializeObject(model));
// Return OK to acknowledge
// message received //
return(Ok());
}
public HttpResponseMessage EventMessages(int id)
{
EventMessageModel eventMessages = ModelHelper.CreateEventMessageModel(UoW.EventMessageRepository.GetEventMessageById(id));
return(Request.CreateResponse(HttpStatusCode.OK, eventMessages));
}
public EventMessageBase()
{
eventMessageModel = EventMessageModel.eEventMessageModel_Null;
eventMessageAction = 0;
modleId = 0;
}
public IActionResult GetMessage([FromBody] EventMessageModel message)
{
return(Ok());
}
public static byte[] ToBytes(this EventMessageModel messageModel)
{
return(ToBytes((string)JsonConvert.SerializeObject(messageModel)));
}
public async Task SendEventAsync(EventMessageModel messageModel)
{
await _sender.SendAsync(messageModel).ConfigureAwait(false);
}
private void sendEventToServiceBusQueue(string deviceId, QueueClient queueClient, EventMessageModel eventMessageModel)
{
try
{
var eventMessage = new
{
companyId = _companyId,
iotDeviceId = deviceId,
messageCatalogId = eventMessageModel.MessageId,
messageType = DocumentType.EventDocument,
eventRuleCatalogId = eventMessageModel.EventRuleId,
eventRuleCatalogName = eventMessageModel.EventRuleName,
eventRuleCatalogDescription = eventMessageModel.EventRuleDescription,
triggeredTime = eventMessageModel.TriggeredTime,
messageDocumentId = eventMessageModel.MessageDocumentId,
messageContent = eventMessageModel.Payload
};
var messageString = JsonConvert.SerializeObject(eventMessage);
var msg = new BrokeredMessage(messageString);
queueClient.Send(msg);
}
catch (Exception ex)
{
_consoleLog.MessageEventError("sendEventToServiceBusQueue Exception: messageId={0}, EventRuleId={1}, triggeredTime={2} payload={3} ex={4}",
eventMessageModel.MessageId, eventMessageModel.EventRuleId, eventMessageModel.TriggeredTime, eventMessageModel.Payload, ex.ToString());
_consoleLog.BlobLogError("sendEventToServiceBusQueue Exception: messageId={0}, EventRuleId={1}, triggeredTime={2} payload={3} ex={4}",
eventMessageModel.MessageId, eventMessageModel.EventRuleId, eventMessageModel.TriggeredTime, eventMessageModel.Payload, ex.ToString());
}
}
private async Task runEventRules(EventProcessorFactoryModel epfm, string deviceId, int messageCatalogId, JObject payload, string messageDocumentId)
{
try
{
var ts = payload["msgTimestamp"];
DateTime msgTimestamp = DateTime.Parse(ts.ToString());
Dictionary <int, List <EventRuleCatalogEngine> > eventRulesInMessageId = epfm.EventRulesInMessageId;
if (eventRulesInMessageId.ContainsKey(messageCatalogId) == true)
{
List <EventRuleCatalogEngine> eventRuleCatalogEngineList = eventRulesInMessageId[messageCatalogId];
foreach (EventRuleCatalogEngine eventRuleCatalogEngine in eventRuleCatalogEngineList)
{
if (eventRuleCatalogEngine.RuleEngineItems.Count > 0)
{
// Get all results of equations
foreach (KeyValuePair <string, RuleEngineItem> ruleEngineItem in eventRuleCatalogEngine.RuleEngineItems)
{
runSingleRuleItem(ruleEngineItem.Value, payload);
}
// Get the result of bitwise operation
bool eventTriggered = compileBitWiseRules(eventRuleCatalogEngine.RuleEngineItems.Count - 1, eventRuleCatalogEngine.RuleEngineItems);
if (eventTriggered)
{
string now = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");
bool eventSent = checkEventTimeWindow(eventRuleCatalogEngine, msgTimestamp);
//_consoleLog.MessageEventDebug("EventRuleCatalogId={0}, eventSent={1}, LastTriggerTime={2}",
// eventRuleCatalogEngine.EventRuleCatalogId, eventSent, eventRuleCatalogEngine.LastTriggerTime.ToString("yyyy-MM-ddTHH:mm:ss"));
//_consoleLog.BlobLogInfo("EventRuleCatalogId={0}, eventSent={1}, LastTriggerTime={2}",
// eventRuleCatalogEngine.EventRuleCatalogId, eventSent, eventRuleCatalogEngine.LastTriggerTime.ToString("yyyy-MM-ddTHH:mm:ss"));
EventMessageModel eventMessageModel = new EventMessageModel(eventRuleCatalogEngine.EventRuleCatalog,
now,
eventSent,
messageDocumentId,
payload);
// Send the Event to Service Bus if it matchs the time window
if (eventSent)
{
sendEventToServiceBusQueue(deviceId, epfm.EventQueueClient, eventMessageModel);
}
// Put the event to Cosmos DB (Hot Data)
string eventDocumentId = await putEvent2CosmosDb(deviceId, epfm.docDBHelper, eventMessageModel);
// Put the event to Blob (Cold Data)
await putEvent2BlobStorage(eventDocumentId, deviceId, eventMessageModel);
}
}
}
}
}
catch (Exception ex)
{
_consoleLog.Error("runEventRules Exception: {0}", ex.ToString());
_consoleLog.BlobLogError("runEventRules Exception: {0}", ex.ToString());
return;
}
}
private async Task putEvent2BlobStorage(string eventDocumentId, string deviceId, EventMessageModel eventMessageModel)
{
DateTime now = DateTime.UtcNow;
string[] dateString = now.ToString("MM/dd/yyyy").Split('/');
string blobName = dateString[2] + "/" + dateString[0] + "/" + dateString[1] + "/" + deviceId + "/" + eventDocumentId + ".json";
var eventData = new
{
companyId = _companyId,
iotDeviceId = deviceId,
messageCatalogId = eventMessageModel.MessageId,
messageType = DocumentType.EventDocument,
eventRuleCatalogId = eventMessageModel.EventRuleId,
eventRuleCatalogName = eventMessageModel.EventRuleName,
eventRuleCatalogDescription = eventMessageModel.EventRuleDescription,
triggeredTime = eventMessageModel.TriggeredTime, // Machine Local Time
eventSent = eventMessageModel.EventSent,
messageDocumentId = eventMessageModel.MessageDocumentId,
eventDocumentId = eventDocumentId,
messageContent = eventMessageModel.Payload
};
await _epfm.EventBlobStorageHelper.Save(blobName, JsonConvert.SerializeObject(eventData));
//_consoleLog.Info("putEvent2BlobStorage: {0}", blobName);
//_consoleLog.BlobLogInfo("putEvent2BlobStorage: {0}", blobName);
}
private async Task <string> putEvent2CosmosDb(string deviceId, DocDBHelper docDBHelper, EventMessageModel eventMessageModel)
{
EventDocument eventDocument = new EventDocument
{
companyId = _companyId,
iotDeviceId = deviceId,
messageCatalogId = eventMessageModel.MessageId,
messageType = DocumentType.EventDocument,
eventRuleCatalogId = eventMessageModel.EventRuleId,
eventRuleCatalogName = eventMessageModel.EventRuleName,
eventRuleCatalogDescription = eventMessageModel.EventRuleDescription,
triggeredTime = eventMessageModel.TriggeredTime, // Machine Local Time
eventSent = eventMessageModel.EventSent,
messageDocumentId = eventMessageModel.MessageDocumentId,
messageContent = eventMessageModel.Payload
};
Document document = await docDBHelper.putDocumentAsync(eventDocument);
//_consoleLog.Info("Event Document.Id={0}", document.Id);
return(document.Id);
}
public async Task SendAsync(EventMessageModel message)
{
var eventData = new EventData(message.ToBytes());
//await _eventHubClient.SendAsync(eventData, PartitionKey).ConfigureAwait(false); // Partition key send events to a single partition only use when need ordered events
await _eventHubClient.SendAsync(eventData).ConfigureAwait(false);
}
