public async Task <IActionResult> Post()
{
string response = string.Empty;
const string SmsDeliveryReportEvent = "Microsoft.Communication.SMSDeliveryReportReceived";
string requestContent = await new StreamReader(Request.Body).ReadToEndAsync();
_logger.LogInformation($"Received events: {requestContent}");
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
eventGridSubscriber.AddOrUpdateCustomEventMapping(SmsDeliveryReportEvent, typeof(SmsDeliveryReportEventData));
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData eventData)
{
_logger.LogInformation($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
else if (eventGridEvent.Data is SmsDeliveryReportEventData deliveryReportEventData)
{
_logger.LogInformation($"Got SmsDeliveryReport event data, messageId: {deliveryReportEventData.MessageId}, DeliveryStatus: {deliveryReportEventData.DeliveryStatus}");
return(new OkObjectResult(deliveryReportEventData.MessageId));
}
}
return(new OkObjectResult(response));
}
/// <inheritdoc/>
public async Task <object> DispatchEventGridEvents(List <EventGridEvent> eventGridEvents)
{
_ = eventGridEvents ?? throw new ArgumentNullException(nameof(eventGridEvents));
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
// Handle Subscription Validation Request:
if (eventGridEvent.EventType == EventTypes.EventGridSubscriptionValidationEvent)
{
_logger.LogEventObject(LogEventIds.ReceivedEventGridSubscriptionValidationEventType, new { EventTypes = eventGridEvent.EventType });
var eventData = JsonConvert.DeserializeObject <SubscriptionValidationEventData>(eventGridEvent.Data.ToString());
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
try
{
// Handle other event types
_ = await HandleEventGridEvent(eventGridEvent).ConfigureAwait(false);
}
catch (Exception e)
{
var eventInfo = new { eventGridEvent.Id, eventGridEvent.EventType, eventGridEvent.DataVersion };
_logger.LogExceptionObject(LogEventIds.ExceptionHandlingEventGridEvent, e, eventInfo);
}
}
return(new OkResult());
}
public IActionResult ProcessEventGridWebhook([FromBody] EventGridEvent[] events, [FromServices] ILogger <WebhookController> logger)
{
if (events == null)
{
return(BadRequest());
}
foreach (EventGridEvent ev in events)
{
// Respond with a SubscriptionValidationResponse to complete the EventGrid subscription
if (ev.EventType == EventTypes.EventGridSubscriptionValidationEvent)
{
var eventValidationData = JsonConvert.DeserializeObject <SubscriptionValidationEventData>(ev.Data.ToString());
var response = new SubscriptionValidationResponse(eventValidationData.ValidationCode);
return(Ok(response));
}
}
//if (evt.EventType == EventTypes.MediaJobStateChangeEvent)
//{
// var data = (evt.Data as JObject).ToObject<MediaJobStateChangeEventData>();
// logger.LogInformation(JsonConvert.SerializeObject(data, Formatting.Indented));
//}
return(BadRequest());
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
string requestContent = await req.Content.ReadAsStringAsync();
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (EventGridEvent azevents in eventGridEvents)
{
if (azevents.Data is SubscriptionValidationEventData)
{
var EventData = (SubscriptionValidationEventData)azevents.Data;
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = EventData.ValidationCode
};
return(req.CreateResponse(HttpStatusCode.OK, responseData));
}
else
{
var jsonString = JsonConvert.SerializeObject(azevents);
var content = new StringContent(jsonString, Encoding.UTF8, "application/json");
var response = await client.PostAsync("https://webhook.site/9d2ae6bf-cd79-4896-b44c-0e60a9e2061a", content);
}
}
return(req.CreateResponse(HttpStatusCode.OK));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info($"C# HTTP trigger function begun");
string response = string.Empty;
const string SubscriptionValidationEvent = "Microsoft.EventGrid.SubscriptionValidationEvent";
string requestContent = await req.Content.ReadAsStringAsync();
log.Info($"Received events: {requestContent}");
EventGridEvent[] eventGridEvents = JsonConvert.DeserializeObject <EventGridEvent[]>(requestContent);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
JObject dataObject = eventGridEvent.Data as JObject;
// Deserialize the event data into the appropriate type based on event type
if (string.Equals(eventGridEvent.EventType, SubscriptionValidationEvent, StringComparison.OrdinalIgnoreCase))
{
var eventData = dataObject.ToObject <SubscriptionValidationEventData>();
log.Info($"Got SubscriptionValidation event data, validationCode: {eventData.ValidationCode}, validationUrl: {eventData.ValidationUrl}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse();
responseData.ValidationResponse = eventData.ValidationCode;
return(req.CreateResponse(HttpStatusCode.OK, responseData));
}
}
// Responding back with a 400 Bad Request is intentional and only for the purpose of demonstrating dead lettering.
return(req.CreateResponse(HttpStatusCode.BadRequest, response));
}
//[ValidateHook]
public IActionResult Post([FromBody] EventModel @event)
{
//@event.Part
if (@event.EventType == "subscriptions.validate")
{
var eventData = ((JObject)(@event.Data)).ToObject <SubscriptionValidationEventDataModel>();
this.logger.LogInformation($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, source: {@event.Source}");
// Do any additional validation (as required) and then return back the below response
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Subscription validation: \r\n {JsonConvert.SerializeObject(@event)}");
Console.ResetColor();
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(Ok(responseData));
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Event received: \r\n {JsonConvert.SerializeObject(@event)}");
Console.ResetColor();
return(Ok());
}
public IActionResult ProcessWorkspaceAddEvent([FromBody] EventGridEvent[] events)
{
foreach (var ev in events)
{
if (ev.EventType == "Accelerant.Workspaces.AddItem")
{
ServiceFactory.WorkspaceService.Add((ev.Data as JObject).ToObject <Accelerant.DataTransfer.Events.Workspace>());
return(Ok(ev.Data));
}
if (ev.EventType == "Accelerant.TaskGraphs.AddItem")
{
ServiceFactory.TaskGraphService.Add((ev.Data as JObject).ToObject <Accelerant.DataTransfer.Events.TaskGraph>());
return(Ok(ev.Data));
}
if (ev.EventType == "Accelerant.TaskNodes.AddItem")
{
var item = (ev.Data as JObject).ToObject <Accelerant.DataTransfer.Events.TaskData>();
ServiceFactory.TaskGraphService.AddTask(item, item.TaskGraphId);
return(Ok(ev.Data));
}
if (ev.EventType == EventTypes.EventGridSubscriptionValidationEvent)
{
var data = (ev.Data as JObject).ToObject <SubscriptionValidationEventData>();
var response = new SubscriptionValidationResponse(data.ValidationCode);
return(Ok(response));
}
}
return(BadRequest());
}
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, TraceWriter log)
{
log.Info($"C# HTTP trigger function begun");
string response = string.Empty;
const string SubscriptionValidationEvent = "Microsoft.EventGrid.SubscriptionValidationEvent";
string requestContent = new StreamReader(req.Body).ReadToEnd();
EventGridEvent[] eventGridEvents = JsonConvert.DeserializeObject <EventGridEvent[]>(requestContent);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
JObject dataObject = eventGridEvent.Data as JObject;
// Deserialize the event data into the appropriate type based on event type
if (string.Equals(eventGridEvent.EventType, SubscriptionValidationEvent, StringComparison.OrdinalIgnoreCase))
{
var eventData = dataObject.ToObject <SubscriptionValidationEventData>();
log.Info($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse();
responseData.ValidationResponse = eventData.ValidationCode;
return((ActionResult) new OkObjectResult(responseData));
}
}
return((ActionResult) new OkObjectResult(response));
}
/// <summary>
/// Validates Azure event subscription and calls the appropriate event handler. Responds HttpOk.
/// </summary>
/// <param name="request">HttpRequest received from Azure</param>
/// <param name="eventTypeHandlers">Dictionary of eventType strings and their associated handlers.</param>
/// <returns>OkObjectResult</returns>
/// <remarks>Reference https://docs.microsoft.com/en-us/azure/event-grid/receive-events</remarks>
public async static Task <OkObjectResult> HandleAzureEvents(HttpRequest request,
Dictionary <string, Func <EventGridEvent, Task> > eventTypeHandlers)
{
var response = string.Empty;
var requestContent = await new StreamReader(request.Body).ReadToEndAsync();
if (string.IsNullOrWhiteSpace(requestContent))
{
return(new OkObjectResult(response));
}
var eventGridSubscriber = new EventGridSubscriber();
var eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (var eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData eventData)
{
// Might want to enable additional validation: subject, topic etc.
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
else if (eventTypeHandlers.ContainsKey(eventGridEvent.EventType))
{
await eventTypeHandlers[eventGridEvent.EventType](eventGridEvent);
}
}
return(new OkObjectResult(response));
}
public static async Task <HttpResponseMessage> CreateCosmosDocument(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage req,
[CosmosDB(databaseName: "sample0102",
collectionName: "sample01",
ConnectionStringSetting = "CosmosDBConnection", CreateIfNotExists = true, PartitionKey = "/sample")]
IAsyncCollector <CosmosFunctionEvent> cosmosevent, ILogger log)
{
EventGridEvent[] events = JsonConvert.DeserializeObject <EventGridEvent[]>(await req.Content.ReadAsStringAsync());
if (events[0].EventType == "Microsoft.EventGrid.SubscriptionValidationEvent")
{
JObject intialvalidationcode = JObject.Parse(JsonConvert.SerializeObject(events[0].Data));
var Response = new SubscriptionValidationResponse()
{
ValidationResponse = (string)intialvalidationcode["validationCode"]
};
return(req.CreateResponse(HttpStatusCode.OK, Response));
}
else
{
foreach (EventGridEvent item in events)
{
CosmosFunctionEvent obj = new CosmosFunctionEvent();
obj.guid = item.Id;
obj.data = item.Data.ToString();
await cosmosevent.AddAsync(obj);
}
return(req.CreateResponse(HttpStatusCode.OK, events));
}
}
public async Task <SubscriptionValidationResponse> Run(EventGridEvent[] eventGridEvents)
{
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
//JObject dataObject = eventGridEvent.Data as JObject;
var test = eventGridEvent.EventType.ToLower() == EventTypeEnumFactory.SubscriptionValidationEvent.ToLower();
// Deserialize the event data into the appropriate type based on event type
if (eventGridEvent.EventType.ToLower() == EventTypeEnumFactory.SubscriptionValidationEvent.ToLower())
{
var json = JsonConvert.SerializeObject(eventGridEvent.Data);
var obj = JsonConvert.DeserializeObject <SubscriptionValidationEventData>(json);
var responseData = new SubscriptionValidationResponse
{
ValidationResponse = obj?.ValidationCode
};
return(responseData);
}
await HandleEventAsync(MapperUtility.Map <EventGridEvent, BaseEvent>(eventGridEvent));
}
await Task.CompletedTask;
return(null);
}
public IActionResult Post([FromBody] JArray requestJArray)
{
var requestContent = requestJArray.ToString();
_logger.LogInformation($"Received events: {requestContent}");
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData eventData)
{
_logger.LogInformation($"Got SubscriptionValidation event data, validationCode: {eventData.ValidationCode}, validationUrl: {eventData.ValidationUrl}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(Ok(responseData));
}
else
{
var statement = new StatementExtension((JObject)eventGridEvent.Data);
var statementWrapper = new StatementWrapper(eventGridEvent.Subject, statement);
_decisionChannel.Next(statementWrapper);
}
}
return(Ok(null));
}
public async Task <ActionResult> CreateWebhook([FromBody] EventGridEvent[] events, [FromServices] ILogger <WebhookController> logger)
{
if (events == null)
{
return(BadRequest());
}
foreach (EventGridEvent ev in events)
{
// Respond with a SubscriptionValidationResponse to complete the EventGrid subscription
if (ev.EventType == EventTypes.EventGridSubscriptionValidationEvent)
{
var eventValidationData = JsonSerializer.Deserialize <SubscriptionValidationEventData>(ev.Data.ToString());
var response = new SubscriptionValidationResponse(eventValidationData.ValidationCode);
return(Ok(response));
}
else
// process message to create contact
{
Contact createC = JsonSerializer.Deserialize <Contact>(ev.Data.ToString());
await cl.PostContactAsync(createC);
return(Ok());
}
}
return(BadRequest());
}
public async Task <IActionResult> ReceiveEvents()
{
using var reader = new StreamReader(Request.Body, Encoding.UTF8);
string requestContent = await reader.ReadToEndAsync().ConfigureAwait(false);
logger.LogInformation($"Received events: {requestContent}");
var eventGridSubscriber = new EventGridSubscriber();
foreach (var key in acceptedEventTypes.Keys)
{
eventGridSubscriber.AddOrUpdateCustomEventMapping(key, typeof(EventGridEventData));
}
var eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (var eventGridEvent in eventGridEvents)
{
if (!Guid.TryParse(eventGridEvent.Id, out Guid eventId))
{
throw new InvalidDataException($"Invalid Guid for EventGridEvent.Id '{eventGridEvent.Id}'");
}
if (eventGridEvent.Data is SubscriptionValidationEventData subscriptionValidationEventData)
{
logger.LogInformation($"Got SubscriptionValidation event data, validationCode: {subscriptionValidationEventData!.ValidationCode}, validationUrl: {subscriptionValidationEventData.ValidationUrl}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = subscriptionValidationEventData.ValidationCode,
};
return(Ok(responseData));
}
else if (eventGridEvent.Data is EventGridEventData eventGridEventData)
{
if (!Guid.TryParse(eventGridEventData.ItemId, out Guid contentId))
{
throw new InvalidDataException($"Invalid Guid for EventGridEvent.Data.ItemId '{eventGridEventData.ItemId}'");
}
var cacheOperation = acceptedEventTypes[eventGridEvent.EventType];
logger.LogInformation($"Got Event Id: {eventId}: {eventGridEvent.EventType}: Cache operation: {cacheOperation} {eventGridEventData.Api}");
var result = await webhookService.ProcessMessageAsync(cacheOperation, eventId, contentId, eventGridEventData.Api).ConfigureAwait(false);
LogResult(eventId, contentId, result);
}
else
{
throw new InvalidDataException($"Invalid event type '{eventGridEvent.EventType}' received for Event Id: {eventId}, should be one of '{string.Join(",", acceptedEventTypes.Keys)}'");
}
}
return(Ok());
}
public async Task <IActionResult> Handler([HttpTrigger] HttpRequestMessage request)
{
var content = await request.Content.ReadAsStringAsync();
var eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(content);
foreach (var ev in eventGridEvents)
{
if (ev.EventType == "Microsoft.EventGrid.SubscriptionValidationEvent")
{
var data = (SubscriptionValidationEventData)ev.Data;
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = data.ValidationCode
};
return(new OkObjectResult(responseData));
}
else if (ev.EventType == "Microsoft.Devices.DeviceTelemetry")
{
log.LogInformation(ev.Data.ToString());
var data = (IotHubDeviceTelemetryEventData)ev.Data;
var digitalTwinId = data.SystemProperties["iothub-connection-device-id"];
JObject jsonBody = default;
if (data.Body is string)
{
var base64 = (string)data.Body;
var bytes = Convert.FromBase64String(base64);
var json = Encoding.UTF8.GetString(bytes);
jsonBody = JsonConvert.DeserializeObject <JObject>(json);
}
else
{
jsonBody = (JObject)data.Body;
}
var humidity = jsonBody.Value <string>("Humidity");
log.LogInformation($"Device:{digitalTwinId} Humidity is:{humidity}");
//Update twin using device temperature
var response = await client.PublishTelemetryAsync(digitalTwinId, null, JsonConvert.SerializeObject(new
{
Humidity = humidity
}));
log.LogInformation($"{digitalTwinId} humidity patched to {humidity}");
// send telemetry
var responseT = await client.PublishTelemetryAsync(digitalTwinId, null, JsonConvert.SerializeObject(new
{
Humidity = humidity
}));
log.LogInformation($"{digitalTwinId} humidity sent {humidity}");
}
}
return(new OkResult());
}
public async Task ProcessAsync(HttpRequest httpRequest, HttpResponse httpResponse, IBot bot,
CancellationToken cancellationToken = default)
{
if (httpRequest == null)
{
throw new ArgumentNullException(nameof(httpRequest));
}
if (httpResponse == null)
{
throw new ArgumentNullException(nameof(httpResponse));
}
if (bot == null)
{
throw new ArgumentNullException(nameof(bot));
}
string body;
using (var sr = new StreamReader(httpRequest.Body))
{
body = await sr.ReadToEndAsync();
}
var eventGridSubscriber = new EventGridSubscriber();
var eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(body);
foreach (var eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData eventData)
{
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
httpResponse.StatusCode = (int)HttpStatusCode.OK;
var responseJson = JsonConvert.SerializeObject(responseData);
var responseDataBytes = Encoding.UTF8.GetBytes(responseJson);
await httpResponse.Body.WriteAsync(responseDataBytes, 0, responseDataBytes.Length).ConfigureAwait(false);
}
else
{
var activity = RequestToActivity(eventGridEvent);
using (var context = new TurnContext(this, activity))
{
context.TurnState.Add("httpStatus", HttpStatusCode.OK.ToString("D"));
await RunPipelineAsync(context, bot.OnTurnAsync, cancellationToken).ConfigureAwait(false);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
}
}
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("IoT Hub Device connection status.");
BinaryData events = await BinaryData.FromStreamAsync(req.Body);
EventGridEvent[] eventGridEvents = EventGridEvent.ParseMany(events);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
// Handle system events
if (eventGridEvent.TryGetSystemEventData(out object eventData))
{
// Handle the subscription validation event
if (eventData is SubscriptionValidationEventData subscriptionValidationEventData)
{
log.LogInformation($"Got SubscriptionValidation event data, validation code: {subscriptionValidationEventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = subscriptionValidationEventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
}
var data = eventGridEvent.Data.ToString();
// "data": {
// "deviceConnectionStateEventInfo": {
// "sequenceNumber": "000000000000000001D4132452F67CE200000002000000000000000000000001"
// },
// "hubName": "townbroadcast-hub",
// "deviceId": "LogicAppTestDevice"
// }
log.LogInformation($"eventGridEvent.Data: {eventGridEvent.Data.ToString()}");
var eventdata = JsonConvert.DeserializeObject <EventGridData>(data);
log.LogInformation($"{eventdata.deviceId} is {(eventGridEvent.EventType == "Microsoft.Devices.DeviceConnected" ? "Connected" : "Disconnected")}");
switch (eventGridEvent.EventType)
{
case "Microsoft.Devices.DeviceDisconnected":
break;
case "Microsoft.Devices.DeviceConnected":
break;
}
}
return(new OkObjectResult(""));
}
public async Task <ActionResult> GetRecordingFile([FromBody] object request)
{
try
{
var httpContent = new BinaryData(request.ToString()).ToStream();
EventGridEvent cloudEvent = EventGridEvent.ParseMany(BinaryData.FromStream(httpContent)).FirstOrDefault();
if (cloudEvent.EventType == SystemEventNames.EventGridSubscriptionValidation)
{
var eventData = cloudEvent.Data.ToObjectFromJson <SubscriptionValidationEventData>();
Logger.LogInformation("Microsoft.EventGrid.SubscriptionValidationEvent response -- >" + cloudEvent.Data);
var responseData = new SubscriptionValidationResponse
{
ValidationResponse = eventData.ValidationCode
};
if (responseData.ValidationResponse != null)
{
return(Ok(responseData));
}
}
if (cloudEvent.EventType == SystemEventNames.AcsRecordingFileStatusUpdated)
{
Logger.LogInformation($"Event type is -- > {cloudEvent.EventType}");
Logger.LogInformation("Microsoft.Communication.RecordingFileStatusUpdated response -- >" + cloudEvent.Data);
var eventData = cloudEvent.Data.ToObjectFromJson <AcsRecordingFileStatusUpdatedEventData>();
Logger.LogInformation("Start processing metadata -- >");
await ProcessFile(eventData.RecordingStorageInfo.RecordingChunks[0].MetadataLocation,
eventData.RecordingStorageInfo.RecordingChunks[0].DocumentId,
FileFormat.Json,
FileDownloadType.Metadata);
Logger.LogInformation("Start processing recorded media -- >");
await ProcessFile(eventData.RecordingStorageInfo.RecordingChunks[0].ContentLocation,
eventData.RecordingStorageInfo.RecordingChunks[0].DocumentId,
string.IsNullOrWhiteSpace(recFileFormat)?FileFormat.Mp4 : recFileFormat,
FileDownloadType.Recording);
}
return(Ok());
}
catch (Exception ex)
{
return(Json(new { Exception = ex }));
}
}
public void Validate_WithValidationResponseData_ReturnsValidationResponse()
{
string expectedValidationCode = "test-validation-code123";
EventGridEvent gridEvent = new EventGridEvent()
{
Data = $"{{ \"validationCode\": \"{expectedValidationCode}\" }}"
};
SubscriptionValidationResponse actual = _validationService.Validate(gridEvent);
string actualValidationCode = actual.ValidationResponse;
Assert.AreEqual(expectedValidationCode, actualValidationCode);
}
public static IActionResult Run([HttpTrigger("post")] HttpRequest request, ILogger logger)
{
SubscriptionValidationResponse validationResponse = null;
try
{
if (request.Query.ContainsKey("id"))
{
logger.LogInformation("Request Query: {0}", request.QueryString);
string insightId = request.Query["id"].ToString();
PublishJobOutput(null, insightId, logger);
}
else
{
StreamReader requestReader = new StreamReader(request.Body);
string requestBody = requestReader.ReadToEnd();
logger.LogInformation("Request Body: {0}", requestBody);
JToken eventInfo = JArray.Parse(requestBody)[0];
if (requestBody.Contains("validationCode"))
{
string validationCode = eventInfo["data"]["validationCode"].ToString();
logger.LogInformation("Validation Code: {0}", validationCode);
validationResponse = new SubscriptionValidationResponse(validationCode);
}
else
{
switch (eventInfo["eventType"].ToString())
{
case "Microsoft.Media.JobStateChange":
string eventSubject = eventInfo["subject"].ToString();
string eventState = eventInfo["data"]["state"].ToString();
if (string.Equals(eventState, "Finished", StringComparison.OrdinalIgnoreCase))
{
string jobName = Path.GetFileName(eventSubject);
logger.LogInformation("Job Name: {0}", jobName);
PublishJobOutput(jobName, null, logger);
}
break;
}
}
}
}
catch (Exception ex)
{
string logData = ex.ToString();
logger.LogError(logData);
throw;
}
return(new OkObjectResult(validationResponse));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info($"C# HTTP trigger function for EventGrid begun");
var response = string.Empty;
var requestContent = await req.Content.ReadAsStringAsync();
var eventGridEvents = JsonConvert.DeserializeObject <EventGridEvent[]>(requestContent);
foreach (var eventGridEvent in eventGridEvents)
{
var dataObject = eventGridEvent.Data as JObject;
// Deserialize the event data into the appropriate type based on event type
if (string.Equals(eventGridEvent.EventType, SubscriptionValidationEvent, StringComparison.OrdinalIgnoreCase))
{
var eventData = dataObject.ToObject <SubscriptionValidationEventData>();
log.Info($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse();
responseData.ValidationResponse = eventData.ValidationCode;
return(req.CreateResponse(HttpStatusCode.OK, responseData));
}
else if (string.Equals(eventGridEvent.EventType, StorageBlobCreatedEvent, StringComparison.OrdinalIgnoreCase))
{
var eventData = dataObject.ToObject <StorageBlobCreatedEventData>();
log.Info($"Got BlobCreated event data, blob URI {eventData.Url}");
// Notify to slack
var payload = new
{
channel = notifySlackChannel,
username = "******",
text = $"New Blob Item was uploaded. Please access from {eventData.Url}",
};
var json = JsonConvert.SerializeObject(payload);
var res = await notify.SendAsync(json);
response = $"Send to Slack for following. text : {payload.text}";
}
log.Info($"=====Debug Message=====");
log.Info($"Subject: {eventGridEvent.Subject}");
log.Info($"Time: {eventGridEvent.EventTime}");
log.Info($"Event data: {eventGridEvent.Data.ToString()}");
}
return(req.CreateResponse(HttpStatusCode.OK, response));
}
private object HandleValidation(EventGridEvent validationEvent)
{
var eventData = ((JObject)validationEvent.Data).ToObject <SubscriptionValidationEventData>();
log.LogInformation($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, topic: {validationEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(responseData);
}
static ActionResult ValidationMessageResponse(EventGridEvent e)
{
var data = e.Data as JObject;
var eventData = data.ToObject <SubscriptionValidationEventData>();
var responseData = new SubscriptionValidationResponse
{
ValidationResponse = eventData.ValidationCode
};
if (responseData.ValidationResponse != null)
{
return(new OkObjectResult(responseData));
}
return(new OkResult());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation($"C# HTTP trigger function begun");
string response = string.Empty;
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
log.LogInformation($"Received events: {requestBody}");
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
eventGridSubscriber.AddOrUpdateCustomEventMapping("eventTypeSms", typeof(SmsContent));
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestBody);
List <string> outputs = new List <string>();
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SmsContent)
{
var eventData = (SmsContent)eventGridEvent.Data;
log.LogInformation($"Got SubscriptionValidation event data, data: '{eventData}', topic: {eventGridEvent.Topic}");
outputs.Add(eventData.ToString());
}
// NEEDED TO SUBSCRIBE OUR WEBHOOK
if (eventGridEvent.Data is SubscriptionValidationEventData)
{
var eventData = (SubscriptionValidationEventData)eventGridEvent.Data;
log.LogInformation($"Got SubscriptionValidation event data, validation code: {eventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
}
return(new OkObjectResult(outputs));
}
public async Task <IActionResult> Post([FromBody] object request)
{
//Deserializing the request
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(request.ToString());
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
// Validate whether EventType is of "Microsoft.EventGrid.SubscriptionValidationEvent"
if (eventGridEvent.EventType == "Microsoft.EventGrid.SubscriptionValidationEvent")
{
var eventData = (SubscriptionValidationEventData)eventGridEvent.Data;
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
if (responseData.ValidationResponse != null)
{
return(Ok(responseData));
}
}
else
{
dynamic configMessage = eventGridEvent.Data;
string key = configMessage.Key.ToString();
if (configMessage.Key == "TestApp:Settings:Message")
{
var result = await AppConfigConnector.GetValue(key, _config);
var message = JsonConvert.DeserializeObject <AppConfigMessage>(result);
await _hubContext.Clients.All.SendAsync("SendMessage", message.Value);
}
}
}
return(Ok());
}
public async Task <IActionResult> ProcessEvent(List <EventGridEvent> eventGridEvents)
{
foreach (var eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData)
{
var eventData = (SubscriptionValidationEventData)eventGridEvent.Data;
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
}
return(new OkObjectResult("The event has been processed."));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info($"C# HTTP trigger function begun");
string response = string.Empty;
const string CustomTopicEvent = "Contoso.Items.ItemReceived";
string requestContent = await req.Content.ReadAsStringAsync();
log.Info($"Received events: {requestContent}");
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
eventGridSubscriber.AddOrUpdateCustomEventMapping(CustomTopicEvent, typeof(ContosoItemReceivedEventData));
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(requestContent);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
if (eventGridEvent.Data is SubscriptionValidationEventData)
{
var eventData = (SubscriptionValidationEventData)eventGridEvent.Data;
log.Info($"Got SubscriptionValidation event data, validationCode: {eventData.ValidationCode}, validationUrl: {eventData.ValidationUrl}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(req.CreateResponse(HttpStatusCode.OK, responseData));
}
else if (eventGridEvent.Data is StorageBlobCreatedEventData)
{
var eventData = (StorageBlobCreatedEventData)eventGridEvent.Data;
log.Info($"Got BlobCreated event data, blob URI {eventData.Url}");
}
else if (eventGridEvent.Data is ContosoItemReceivedEventData)
{
var eventData = (ContosoItemReceivedEventData)eventGridEvent.Data;
log.Info($"Got ContosoItemReceived event data, item SKU {eventData.ItemSku}");
}
}
return(req.CreateResponse(HttpStatusCode.OK, response));
}
public IActionResult Post([FromBody] List <GridEvent <object> > events)
{
if (events == null)
{
return(Ok());
}
foreach (var event1 in events)
{
if (event1.EventType == "Microsoft.EventGrid.SubscriptionValidationEvent")
{
var eventData = JsonConvert.DeserializeObject <SubscriptionValidationEventData>(event1.Data.ToString());
var responseData = new SubscriptionValidationResponse();
responseData.ValidationResponse = eventData.ValidationCode;
return(Ok(responseData));
}
}
return(Ok());
}
public IActionResult Index([FromBody] object request)
{
var EventGrid = JsonConvert.DeserializeObject <EventGridEvent[]>(request.ToString()).FirstOrDefault();
// First EventGrid will send a ValidationEvent for creating a handshake.
if (string.Equals(EventGrid.EventType, "Microsoft.EventGrid.SubscriptionValidationEvent", StringComparison.OrdinalIgnoreCase))
{
var data = EventGrid.Data as JObject;
if (data != null)
{
var eventData = data.ToObject <SubscriptionValidationEventData>();
var responseData = new SubscriptionValidationResponse
{
ValidationResponse = eventData.ValidationCode
};
if (responseData.ValidationResponse != null)
{
// Handshake between EventGrid and web hook.
// Web App has to send the validation code back to the Azure service.
return(Ok(responseData));
}
}
else
{
return(Ok());
}
}
else
{
var data = EventGrid.Data as JObject;
string topic = EventGrid.Topic;
foreach (JProperty property in data.Properties())
{
string name = property.Name.ToString();
string val = property.Value.ToString();;
}
return(Ok());
}
return(Ok());
}
public IActionResult Post([FromBody] object request)
{
//Deserializing the request
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
EventGridEvent[] eventGridEvents = eventGridSubscriber.DeserializeEventGridEvents(request.ToString());
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
// Validate whether EventType is of "Microsoft.EventGrid.SubscriptionValidationEvent"
if (eventGridEvent.EventType == "Microsoft.EventGrid.SubscriptionValidationEvent")
{
var eventData = (SubscriptionValidationEventData)eventGridEvent.Data;
// Do any additional validation (as required) such as validating that the Azure resource ID of the topic matches
// the expected topic and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
if (responseData.ValidationResponse != null)
{
return(Ok(responseData));
}
}
else
{
var truck = JsonConvert.DeserializeObject <Truck>(eventGridEvent.Data.ToString());
object[] args = { truck.TruckId, truck };
_hubContext.Clients.All.SendCoreAsync("SendMessage", args);
Console.WriteLine(truck);
}
}
return(Ok());
}
