public static async Task Run(
[EventGridTrigger] EventGridEvent eventGridEvent,
[Blob("{data.url}", FileAccess.Read)] Stream input,
ILogger log)
{
var createdEvent = ((JObject)eventGridEvent.Data).ToObject <StorageBlobCreatedEventData>();
int width = 100;
int height = 100;
var thumbContainerName = Environment.GetEnvironmentVariable("THUMBNAIL_CONTAINER_NAME");
var storageAccount = CloudStorageAccount.Parse(BLOB_STORAGE_CONNECTION_STRING);
var blobClient = storageAccount.CreateCloudBlobClient();
var container = blobClient.GetContainerReference(thumbContainerName);
var blobName = GetBlobNameFromUrl(createdEvent.Url);
var blockBlob = container.GetBlockBlobReference(blobName);
using (var stream = new MemoryStream())
using (var image = new Bitmap(input))
{
var extension = Path.GetExtension(createdEvent.Url);
var encoder = GetEncoder(extension);
var resized = new Bitmap(width, height);
using (var graphics = Graphics.FromImage(resized))
{
graphics.CompositingQuality = CompositingQuality.HighSpeed;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingMode = CompositingMode.SourceCopy;
graphics.DrawImage(image, 0, 0, width, height);
resized.Save(stream, encoder);
await blockBlob.UploadFromStreamAsync(stream);
}
}
}
public static void NewAudioFileEventGridTrigger([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log, ExecutionContext context)
{
string SubscriptionKey = System.Environment.GetEnvironmentVariable("SubscriptionKey");
string SASToken = System.Environment.GetEnvironmentVariable("SASToken");
string AddDiarizationString = System.Environment.GetEnvironmentVariable("AddDiarization");
bool AddDiarization = bool.Parse(AddDiarizationString);
string HostName = string.Format(HostNameTempalte, System.Environment.GetEnvironmentVariable("Region"));
log.LogInformation(eventGridEvent.Data.ToString());
var client = BatchClient.CreateApiV2Client(SubscriptionKey, HostName, Port, log);
dynamic eventData = JObject.Parse(eventGridEvent.Data.ToString());
string url = eventData.url;
log.LogInformation(url);
Task <Uri> task = client.PostTranscriptionAsync(Name, Description, Locale, new Uri(url + SASToken), AddDiarization);
task.Wait();
Uri Location = task.Result;
if (Location != null)
{
log.LogInformation(Location.AbsoluteUri);
}
}
public async Task DispatchEventAsync(string endpointUrl, EventGridEvent ev)
{
_logger.LogInfo($"{Environment.NewLine}Dispatching event (Id: {ev.Id}) to '{endpointUrl}' using '{nameof(DefaultHttpStrategy)}'");
var json = JsonConvert.SerializeObject(new EventGridEvent[] { ev });
using (var content = new StringContent(json, Encoding.UTF8, JsonMimeType))
{
try
{
// Send request
var result = await _httpClient.PostAsync(endpointUrl, content);
if (!result.IsSuccessStatusCode)
{
_logger.LogError(result.ToString());
}
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
}
}
public static async Task Main(string[] args)
{
Uri endpoint = new Uri(topicEndpoint);
AzureKeyCredential credential = new AzureKeyCredential(topicKey);
EventGridPublisherClient client = new EventGridPublisherClient(endpoint, credential);
EventGridEvent firstEvent = new EventGridEvent(
subject: $"New Employee: Alba Sutton",
eventType: "Employees.Registration.New",
dataVersion: "1.0",
data: new
{
FullName = "Alba Sutton",
Address = "4567 Pine Avenue, Edison, WA 97202"
}
);
EventGridEvent secondEvent = new EventGridEvent(
subject: $"New Employee: Alexandre Doyon",
eventType: "Employees.Registration.New",
dataVersion: "1.0",
data: new
{
FullName = "Alexandre Doyon",
Address = "456 College Street, Bow, WA 98107"
}
);
await client.SendEventAsync(firstEvent);
Console.WriteLine("primer evnto publicado");
await client.SendEventAsync(secondEvent);
Console.WriteLine("segundo evento publicado");
}
public static bool AcceptsEvent(this AdvancedFilterSetting filter, EventGridEvent gridEvent)
{
var retVal = filter == null;
if (retVal)
{
return(true);
}
// filter is not null
if (!gridEvent.TryGetValue(filter.Key, out var value))
{
return(false);
}
switch (filter.OperatorType)
{
case AdvancedFilterSetting.OperatorTypeEnum.NumberGreaterThan:
retVal = Try(() => value.ToNumber() > filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberGreaterThanOrEquals:
retVal = Try(() => value.ToNumber() >= filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberLessThan:
retVal = Try(() => value.ToNumber() < filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberLessThanOrEquals:
retVal = Try(() => value.ToNumber() <= filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberIn:
retVal = Try(() => (filter.Values ?? new object[0]).Select(v => v.ToNumber()).Contains(value.ToNumber()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberNotIn:
retVal = Try(() => !(filter.Values ?? new object[0]).Select(v => v.ToNumber()).Contains(value.ToNumber()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.BoolEquals:
retVal = Try(() => Convert.ToBoolean(value) == Convert.ToBoolean(filter.Value));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringContains:
{
// a string cannot be considered to contain null or and empty string
var valueAsString = value as string;
var filterValueAsString = filter.Value as string;
retVal = Try(() => !string.IsNullOrEmpty(filterValueAsString) &&
!string.IsNullOrEmpty(valueAsString) &&
valueAsString.Contains(filterValueAsString, StringComparison.OrdinalIgnoreCase));
}
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringBeginsWith:
{
// null or empty values cannot be considered to be the beginning character of a string
var valueAsString = value as string;
var filterValueAsString = filter.Value as string;
retVal = Try(() => !string.IsNullOrEmpty(filterValueAsString) &&
!string.IsNullOrEmpty(valueAsString) &&
valueAsString.StartsWith(filterValueAsString, StringComparison.OrdinalIgnoreCase));
}
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringEndsWith:
{
// null or empty values cannot be considered to be the end character of a string
var valueAsString = value as string;
var filterValueAsString = filter.Value as string;
retVal = Try(() => !string.IsNullOrEmpty(filterValueAsString) &&
!string.IsNullOrEmpty(valueAsString) &&
valueAsString.EndsWith(filterValueAsString, StringComparison.OrdinalIgnoreCase));
}
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringIn:
retVal = Try(() => (filter.Values ?? new object[0]).Select(v => Convert.ToString(v)?.ToUpper()).Contains(Convert.ToString(value)?.ToUpper()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringNotIn:
retVal = Try(() => !(filter.Values ?? new object[0]).Select(v => Convert.ToString(v)?.ToUpper()).Contains(Convert.ToString(value)?.ToUpper()));
break;
}
return(retVal);
}
public static void Run(
ILogger logger,
[EventGridTrigger] EventGridEvent e)
{
logger.LogInformation("Event received {type} {subject}", e.EventType, e.Subject);
}
private static bool IsSubscriptionValidationEvent(EventGridEvent eventGridEvent)
{
return(string.Equals(eventGridEvent.EventType, SubscriptionValidationEvent, StringComparison.OrdinalIgnoreCase));
}
public EventBenchmark()
{
string sample_event = File.ReadAllText($"{cwd}\\event.json");
eventGridEvent = JsonConvert.DeserializeObject <EventGridEvent>(sample_event);
}
public void SingleEvent([EventGrid(TopicEndpointUri = "eventgridUri", TopicKeySetting = "eventgridKey")] out EventGridEvent single)
{
single = new EventGridEvent("0", "", "", "");
}
public async Task Run(
[EventGridTrigger()] EventGridEvent eventGridEvent,
ILogger logger)
{
try
{
EventSchema reservationEvent = new EventSchema()
{
ID = eventGridEvent.Id,
BookReservation = ((JObject)eventGridEvent.Data).ToObject <BookReservation>(),
EventTime = eventGridEvent.EventTime,
EventType = (ReservationStatus)Enum.Parse(typeof(ReservationStatus), eventGridEvent.EventType),
Subject = eventGridEvent.Subject
};
try
{
logger.LogInformation(new EventId(Convert.ToInt32(Logging.EventId.CreateReserveration)),
Logging.LoggingTemplate,
reservationEvent.BookReservation.CorrelationID,
nameof(CreateReservation),
reservationEvent.EventType.ToString(),
Logging.Status.Started.ToString(),
"Creating auditing entry."
);
await _sqlHelper.CreateReservation(reservationEvent).ConfigureAwait(false);
logger.LogInformation(new EventId(Convert.ToInt32(Logging.EventId.CreateReserveration)),
Logging.LoggingTemplate,
reservationEvent.BookReservation.CorrelationID,
nameof(CreateReservation),
reservationEvent.EventType.ToString(),
Logging.Status.Succeeded.ToString(),
"Completed creating auditing entry."
);
}
catch (Exception ex)
{
//Output Exception Event
logger.LogError(new EventId(Convert.ToInt32(Logging.EventId.CreateReserveration)),
Logging.LoggingTemplate,
reservationEvent.BookReservation.CorrelationID,
nameof(CreateReservation),
reservationEvent.EventType.ToString(),
Logging.Status.Failed.ToString(),
string.Format("Failed while creating auditing entry. Exception {0}", ex.Message)
);
}
}
catch (Exception ex)
{
logger.LogError(new EventId(Convert.ToInt32(Logging.EventId.CreateReserveration)),
Logging.GenericExceptionLoggingTemplate,
nameof(CreateReservation),
Logging.Status.Failed.ToString(),
string.Format("Failed while parsing incoming event. Exception {0}", ex.Message)
);
}
}
public static async Task RunAsync([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
//Extracting content type and url of the blob triggering the function
var jsondata = JsonConvert.SerializeObject(eventGridEvent.Data);
var tmp = new { contentType = "", url = "" };
var data = JsonConvert.DeserializeAnonymousType(jsondata, tmp);
//Checking if the trigger was iniatiated for a PDF File.
if (data.contentType == "application/pdf")
{
var pdfUrl = data.url;
string endpoint = System.Environment.GetEnvironmentVariable("FormsRecognizerEndpoint", EnvironmentVariableTarget.Process);
string apiKey = System.Environment.GetEnvironmentVariable("FormsRecognizerKey", EnvironmentVariableTarget.Process);
string contosoStorageConnectionString = System.Environment.GetEnvironmentVariable("ContosoStorageConnectionString", EnvironmentVariableTarget.Process);
string cosmosEndpointUrl = System.Environment.GetEnvironmentVariable("CosmosDBEndpointUrl", EnvironmentVariableTarget.Process);
string cosmosPrimaryKey = System.Environment.GetEnvironmentVariable("CosmosDBPrimaryKey", EnvironmentVariableTarget.Process);
//Create a SAS Link to give Forms Recognizer read access to the document
BlobServiceClient blobServiceClient = new BlobServiceClient(contosoStorageConnectionString);
BlobContainerClient container = new BlobContainerClient(contosoStorageConnectionString, "claims");
string blobName = pdfUrl.Split('/').Last();
BlobClient blob = container.GetBlobClient(blobName);
BlobSasBuilder sasBuilder = new BlobSasBuilder()
{
BlobContainerName = blob.GetParentBlobContainerClient().Name,
BlobName = blob.Name,
Resource = "b"
};
sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddHours(1);
sasBuilder.SetPermissions(BlobSasPermissions.Read);
Uri sasUri = blob.GenerateSasUri(sasBuilder);
var credential = new AzureKeyCredential(apiKey);
//Get the latest trained model
var formTrainingClient = new FormTrainingClient(new Uri(endpoint), credential);
Pageable <CustomFormModelInfo> formsModels = formTrainingClient.GetCustomModels();
var latestModel = (from inc in formsModels orderby inc.TrainingCompletedOn descending select inc).FirstOrDefault();
//TODO:Run the document through the model
//Insert documents into CosmosDB
var cosmosClient = new CosmosClient(cosmosEndpointUrl, cosmosPrimaryKey);
var cosmosDatabase = (await cosmosClient.CreateDatabaseIfNotExistsAsync("Contoso")).Database;
var cosmosContainer = (await cosmosDatabase.CreateContainerIfNotExistsAsync("Claims", "/InsuredID")).Container;
Model.ClaimsDocument processedDocument = new Model.ClaimsDocument();
processedDocument.DocumentDate = new DateTime(int.Parse(blobName.Substring(0, 4)),
int.Parse(blobName.Substring(4, 2)), int.Parse(blobName.Substring(6, 2)));
processedDocument.PatientName = forms[0].Fields["PatientName"].ValueData?.Text;
processedDocument.InsuredID = forms[0].Fields["InsuredID"].ValueData?.Text;
processedDocument.Diagnosis = forms[0].Fields["Diagnosis"].ValueData?.Text;
decimal.TryParse(forms[0].Fields["TotalCharges"].ValueData?.Text, out decimal totalCharges);
processedDocument.TotalCharges = totalCharges;
DateTime.TryParse(forms[0].Fields["PatientBirthDate"].ValueData?.Text, out DateTime patientBirthDate);
processedDocument.PatientBirthDate = patientBirthDate;
decimal.TryParse(forms[0].Fields["AmountPaid"].ValueData?.Text, out decimal amountPaid);
processedDocument.AmountPaid = amountPaid;
decimal.TryParse(forms[0].Fields["AmountDue"].ValueData?.Text, out decimal amountDue);
processedDocument.AmountDue = amountDue;
processedDocument.FileName = blobName;
if (processedDocument.InsuredID == null)
{
processedDocument.Id = Guid.NewGuid().ToString();
}
else
{
processedDocument.Id = processedDocument.InsuredID;
}
try
{
ItemResponse <Model.ClaimsDocument> cosmosResponse = await
cosmosContainer.CreateItemAsync(processedDocument, new PartitionKey(processedDocument.InsuredID));
}
catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.Conflict)
{
//Conflicting EnsurerID is silently ignored for demo purposes.
}
}
log.LogInformation(eventGridEvent.Data.ToString());
}
public static void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
var result = ExecuteTask();
log.LogInformation(eventGridEvent.Data.ToString());
}
// different argument types
public void TestEventGrid([EventGridTrigger] EventGridEvent value)
{
functionOut = value.Subject;
}
public static void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
System.Text.StringBuilder ErrorRecords = new System.Text.StringBuilder();
System.Text.StringBuilder AcceptedRecords = new System.Text.StringBuilder();
RootObject rootObject = Newtonsoft.Json.JsonConvert.DeserializeObject <RootObject>(eventGridEvent.Data.ToString());
if (rootObject.url.Contains("/LandBlob/"))
{
string blobName = rootObject.url.Substring(rootObject.url.IndexOf("/claimshark/")).Replace("/claimshark/", "");
string PayerID = blobName.Split("/")[0];
if (!CheckFileExists(PayerID, System.IO.Path.GetFileName(blobName)))
{
CloudStorageAccount mycloudStorageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("StorageConnection"));
CloudBlobClient blobClient = mycloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("claimshark");
CloudBlob cloudBlockBlob = container.GetBlobReference(blobName);
string text;
List <FileError> fileErrors = new List <FileError>();
using (var stream = new System.IO.MemoryStream())
{
cloudBlockBlob.DownloadToStreamAsync(stream).Wait();
text = System.Text.Encoding.UTF8.GetString(stream.ToArray());
}
if (!String.IsNullOrEmpty(text))
{
var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string PayerSchemaFile = Path.Combine(binDirectory, PayerID + ".json");
string PayerSchema;
if (System.IO.File.Exists(PayerSchemaFile))
{
PayerSchema = File.ReadAllText(PayerSchemaFile);
}
else
{
binDirectory = binDirectory.Substring(0, binDirectory.LastIndexOf(@"\"));
PayerSchemaFile = Path.Combine(binDirectory, PayerID + ".json");
PayerSchema = File.ReadAllText(PayerSchemaFile);
}
FileSchema fileSchema = Newtonsoft.Json.JsonConvert.DeserializeObject <FileSchema>(PayerSchema);
CreateTable(fileSchema.Fileds);
string[] data = text.Split('\n');
int LineNo = 1;
foreach (var value in data)
{
if (value.Trim().Length > 0)
{
System.Data.DataRow dataRow = dtPayerDataTable.NewRow();
dataRow["IsValid"] = 1;
if (fileSchema.FieldSeprator == "FixedLength")
{
int startPosition = 1;
int fieldLength = 0;
foreach (var field in fileSchema.Fileds)
{
fieldLength = Convert.ToInt32(field.Length);
if (value.Length >= (startPosition + fieldLength))
{
dataRow[field.FieldName] = value.Substring(startPosition - 1, fieldLength);
if (field.IsRequired == "Yes")
{
if (value.Substring(startPosition - 1, fieldLength).Trim().Length <= 0)
{
fileErrors.Add(new FileError()
{
FieldName = field.FieldName,
StartingPostiton = startPosition.ToString(),
FileLinePosition = LineNo.ToString()
});
dataRow["IsValid"] = 0;
}
}
}
else
{
if (value.Length > startPosition)
{
dataRow[field.FieldName] = value.Substring(startPosition - 1);
if (field.IsRequired == "Yes")
{
if (value.Substring(startPosition - 1).Trim().Length <= 0)
{
fileErrors.Add(new FileError()
{
FieldName = field.FieldName,
StartingPostiton = startPosition.ToString(),
FileLinePosition = LineNo.ToString()
});
dataRow["IsValid"] = 0;
}
}
break;
}
}
startPosition += fieldLength;
}
dtPayerDataTable.Rows.Add(dataRow);
}
}
if (fileErrors.Count > 0)
{
ErrorRecords.Append(value);
}
else
{
AcceptedRecords.Append(value);
}
LineNo += 1;
}
}
LogFileDetails(fileErrors, blobName, PayerID);
UploadBlob(fileErrors, ErrorRecords, AcceptedRecords, blobName, PayerID);
SendEmail(blobName, PayerID);
log.LogInformation(Newtonsoft.Json.JsonConvert.SerializeObject(fileErrors));
}
}
}
public async Task Run([EventGridTrigger] EventGridEvent eventGridEvent)
{
var categoryDeletedEvent = JsonConvert.DeserializeObject <CategoryDeletedEvent>(eventGridEvent.Data.ToString());
await _categoryRepository.Delete(categoryDeletedEvent.Id);
}
public static bool AcceptsEvent(this AdvancedFilterSetting filter, EventGridEvent gridEvent)
{
var retVal = filter == null;
if (!retVal)
{
// filter is not null
if (gridEvent.TryGetValue(filter.Key, out var value))
{
switch (filter.OperatorType)
{
case AdvancedFilterSetting.OperatorTypeEnum.NumberGreaterThan:
retVal = Try(() => value.ToNumber() > filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberGreaterThanOrEquals:
retVal = Try(() => value.ToNumber() >= filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberLessThan:
retVal = Try(() => value.ToNumber() < filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberLessThanOrEquals:
retVal = Try(() => value.ToNumber() <= filter.Value.ToNumber());
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberIn:
retVal = Try(() => (filter.Values ?? new object[0]).Select(v => v.ToNumber()).Contains(value.ToNumber()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.NumberNotIn:
retVal = Try(() => !(filter.Values ?? new object[0]).Select(v => v.ToNumber()).Contains(value.ToNumber()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.BoolEquals:
retVal = Try(() => Convert.ToBoolean(value) == Convert.ToBoolean(filter.Value));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringContains:
// a string cannot be considered to contain null or and empty string
retVal = Try(() => !string.IsNullOrEmpty(Convert.ToString(filter.Value)) && Convert.ToString(value).ToUpper().Contains(Convert.ToString(filter.Value).ToUpper()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringBeginsWith:
// null or empty values cannot be considered to be the beginning character of a string
retVal = Try(() => !string.IsNullOrEmpty(Convert.ToString(filter.Value)) && Convert.ToString(value).ToUpper().StartsWith(Convert.ToString(filter.Value).ToUpper()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringEndsWith:
// null or empty values cannot be considered to be the end character of a string
retVal = Try(() => !string.IsNullOrEmpty(Convert.ToString(filter.Value)) && Convert.ToString(value).ToUpper().EndsWith(Convert.ToString(filter.Value).ToUpper()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringIn:
retVal = Try(() => (filter.Values ?? new object[0]).Select(v => Convert.ToString(v).ToUpper()).Contains(Convert.ToString(value).ToUpper()));
break;
case AdvancedFilterSetting.OperatorTypeEnum.StringNotIn:
retVal = Try(() => !(filter.Values ?? new object[0]).Select(v => Convert.ToString(v).ToUpper()).Contains(Convert.ToString(value).ToUpper()));
break;
}
}
}
return(retVal);
}
public static void Run([EventGridTrigger] EventGridEvent eventTrigger, ILogger logger)
{
logger.LogInformation(JsonConvert.SerializeObject(eventTrigger, Formatting.Indented));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
var stackexchangeResponseItem = new StackExchangeResponseItem();
log.LogInformation("C# HTTP trigger function processed a request.");
log.LogInformation($"Received event: {req.Body}");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
EventGridSubscriber eventGridSubscriber = new EventGridSubscriber();
EventGridEvent eventGridEvent = eventGridSubscriber.DeserializeEventGridEvents(requestBody)[0];
var data = JsonConvert.SerializeObject(eventGridEvent.Data);
stackexchangeResponseItem = JsonConvert.DeserializeObject <StackExchangeResponseItem>(data);
var card = new ToTeams();
var tags = string.Join('|', stackexchangeResponseItem.tags);
var section1 = new Section()
{
activityTitle = stackexchangeResponseItem.title, activityText = stackexchangeResponseItem.owner.user_id.ToString(), activitySubtitle = "Tags used: " + tags, activityImage = "stackexchangeResponseItem.owner.profile_image"
};
var image = new Image();
image.image = stackexchangeResponseItem.owner.profile_image;
var potentialAction = new PotentialAction();
potentialAction.context = "http://shema.org";
potentialAction.type = "ViewAction";
potentialAction.name = "Open in browser";
potentialAction.target = new List <string>();
potentialAction.target.Add(stackexchangeResponseItem.link);
potentialAction.id = "SELink";
card.content = new Content()
{
title = "New Question", summary = "Summary", sections = new List <Section>()
};
card.content.sections.Add(section1);
card.content.potentialAction = new List <PotentialAction>();
card.content.potentialAction.Add(potentialAction);
var contentJson = "";
log.LogInformation("content json: " + contentJson);
try
{
contentJson = JsonConvert.SerializeObject(card.content, Formatting.None, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
}
catch (Exception ex)
{
log.LogInformation(ex.Message);
throw;
}
var requestUri = "https://outlook.office.com/webhook/cd95bc39-d4b6-47f5-af91-d1bb60673ea5@72f988bf-86f1-41af-91ab-2d7cd011db47/IncomingWebhook/34d5542e15ea4494a397f6081eb1ffbf/ccd20272-10db-42f9-81ff-7ef56c960fc0";
var content = new StringContent(contentJson);
HttpRequestMessage request = new HttpRequestMessage
{
Content = content
};
var postResponse = await httpClient.PostAsync(requestUri, content);
var postResponseContent = await postResponse.Content.ReadAsStringAsync();
var postResponseHeaders = postResponse.Headers;
return((ActionResult) new OkObjectResult(requestBody));
}
public void TestEventGridToNuget_Single([EventGridTrigger] EventGridEvent value)
{
_functionOut = value.Subject;
}
public static async Task Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
// Process Device Events from IoT Hub
// https://docs.microsoft.com/en-us/azure/event-grid/event-schema-iot-hub?tabs=event-grid-event-schema
_logger = log;
JObject deviceEventData = (JObject)JsonConvert.DeserializeObject(eventGridEvent.Data.ToString());
//log.LogInformation($"Event Type {eventGridEvent.EventType.ToString()}");
log.LogInformation(eventGridEvent.ToString());
// Sanity check
if (deviceEventData == null)
{
log.LogError("Invalid input : Event Data is NULL");
return;
}
if (_serviceClient == null)
{
// Create IoT Hub Service Client
// https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.devices.serviceclient?view=azure-dotnet
_serviceClient = ServiceClient.CreateFromConnectionString(_iotHubConnectionString);
}
if (_serviceClient == null)
{
log.LogError("Failed to create to Service Client");
return;
}
if (_registryManager == null)
{
// Create Registry Manager
// https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.devices.registrymanager?view=azure-dotnet
_registryManager = RegistryManager.CreateFromConnectionString(_iotHubConnectionString);
}
if (_registryManager == null)
{
log.LogError("Failed to create to Registry Manager");
return;
}
switch (eventGridEvent.EventType)
{
case IotHubDeviceConnected:
await ProcessDeviceConnected(deviceEventData, log);
break;
case IotHubDeviceDisconnected:
await ProcessDeviceDisconnected(deviceEventData, log);
break;
case IotHubDeviceCreated:
await ProcessDeviceCreated(deviceEventData, log);
break;
case IotHubDeviceDeleted:
await ProcessDeviceDeleted(deviceEventData, log);
break;
}
}
public static async Task EventGridTest([EventGridTrigger] EventGridEvent eventGridEvent,
[SignalR(HubName = HubName)] IAsyncCollector <SignalRMessage> signalRMessages,
[Table(TableName)] CloudTable cloudTable,
ILogger log)
{
var message = ((JObject)eventGridEvent.Data).ToObject <SignalREvent>();
var partitionKey = GetLastPart(eventGridEvent.Topic);
var rowKey = message.HubName;
var isSuccess = true;
var newConnectionCount = 0;
while (isSuccess)
{
try
{
ConnectionCountEntity entity;
var operation = TableOperation.Retrieve <ConnectionCountEntity>(partitionKey, rowKey);
var result = await cloudTable.ExecuteAsync(operation);
if (result.Result == null)
{
entity = new ConnectionCountEntity(partitionKey, rowKey)
{
Count = newConnectionCount = IsConnectedEvent(eventGridEvent.EventType) ? 1 : 0
};
operation = TableOperation.Insert(entity);
}
else
{
entity = (ConnectionCountEntity)result.Result;
entity.Count = newConnectionCount = entity.Count + (IsConnectedEvent(eventGridEvent.EventType) ? 1 : -1);
operation = TableOperation.Replace(entity);
}
await cloudTable.ExecuteAsync(operation);
isSuccess = false;
}
catch (Exception ex)
{
log.LogError(ex, "Failed to complete operation with storage");
}
}
if (IsConnectedEvent(eventGridEvent.EventType))
{
await signalRMessages.AddAsync(new SignalRMessage
{
ConnectionId = message.ConnectionId,
Target = "newMessage",
Arguments = new[] { new ChatMessage
{
Text = "Welcome to Serverless Chat",
Sender = "__SYSTEM__",
} }
});
}
await signalRMessages.AddAsync(new SignalRMessage
{
Target = "connectionCount",
Arguments = new[] { (object)newConnectionCount },
});
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")]
HttpRequestMessage req,
ILogger log)
{
// Required environment variables
//if (Environment.GetEnvironmentVariable("CognitiveServicesKey") != null &&
// Environment.GetEnvironmentVariable("RedisConnectionString") != null &&
//Environment.GetEnvironmentVariable("CosmosDbKey") != null)
//{
// _cognitiveServicesKey = Environment.GetEnvironmentVariable("CognitiveServicesKey", EnvironmentVariableTarget.Process);
// _redisConnectionString = Environment.GetEnvironmentVariable("RedisConnectionString", EnvironmentVariableTarget.Process);
// _cosmosDbKey = Environment.GetEnvironmentVariable("CosmosDbKey", EnvironmentVariableTarget.Process);
//}
_cognitiveServicesKey = "7b17c215156240d4aaf8625462269fbf";
_redisConnectionString = "hackteam7.redis.cache.windows.net:6379,password=49FMcedUIRrSmtqE6HICWdkjRbAxWkh0LQGFyo4So5E=,ssl=False,abortConnect=False";
_cosmosDbKey = "TfdAclFqUhYimGw1qvmDoGKPT3mbe4zXkv72yFjwbJiyHCKz5lij7Ypv2udTgBq5U2bdjyMlO6CsRGqO9kygqA==";
if (string.IsNullOrEmpty(_cognitiveServicesKey))
{
throw new NullReferenceException("Cognitive Services api key is missing!");
}
if (string.IsNullOrEmpty(_redisConnectionString))
{
throw new NullReferenceException("Redis Connection String is missing!");
}
log.LogInformation("New Event Grid message received.");
var messages = await req.Content.ReadAsAsync <JArray>();
// If the request is for subscription validation, send back the validation code.
if (messages.Count > 0 && string.Equals((string)messages[0]["eventType"],
"Microsoft.EventGrid.SubscriptionValidationEvent",
StringComparison.OrdinalIgnoreCase))
{
log.LogInformation("Validate request received");
return(req.CreateResponse <object>(new
{
validationResponse = messages[0]["data"]["validationCode"]
}));
}
/*
* Initialise external services
*/
ComputerVisionClient computerVision = new ComputerVisionClient(
new ApiKeyServiceClientCredentials(_cognitiveServicesKey))
{
Endpoint = "https://westeurope.api.cognitive.microsoft.com"
};
var conn = ConnectionMultiplexer.Connect(_redisConnectionString);
foreach (var jToken in messages)
{
var message = (JObject)jToken;
// Handle one event.
EventGridEvent eventGridEvent = message.ToObject <EventGridEvent>();
log.LogInformation($"Subject: {eventGridEvent.Subject}");
log.LogInformation($"Time: {eventGridEvent.EventTime}");
log.LogInformation($"Event data: {eventGridEvent.Data}");
try
{
var alert = JsonConvert.DeserializeObject <Alert>(eventGridEvent.Data.ToString());
log.LogInformation("Alert received {0}", JsonConvert.SerializeObject(alert));
log.LogInformation("Performing analysis");
var imageAnalysis = await AnalyzeAsync(computerVision, alert.Image, log);
log.LogInformation("Alert analysis complete {0}", JsonConvert.SerializeObject(imageAnalysis));
var personTag = imageAnalysis.Tags.FirstOrDefault(t => t.Name == "person" && t.Confidence >= 0.90);
AlertEvent alertEvent;
if (personTag == null)
{
log.LogInformation("Alert raised by a non-person object.");
alertEvent = new AlertEvent(
alert.DeviceId,
alert.Name,
"non-person object has been spotted.",
alert.Longitude,
alert.Latitude,
Status.Ok);
}
else
{
log.LogInformation("Alert raised by a person object. We are {0} percent sure.", Math.Round(personTag.Confidence * 100, 2));
alertEvent = new AlertEvent(
alert.DeviceId,
alert.Name,
"person has been spotted! quick, catch them.",
alert.Longitude,
alert.Latitude,
Status.Error);
}
var client = new DocumentClient(new Uri("https://alertdb.documents.azure.com:443/"), _cosmosDbKey);
await client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri("AlertSQLDb", "AlertsCollection"), alertEvent);
await conn.GetDatabase(0)
.PublishAsync(new RedisChannel("alerts", RedisChannel.PatternMode.Auto), alertEvent.ToString());
log.LogInformation("Alert successfully sent to redis for further processing.");
}
catch (Exception ex)
{
log.LogError(ex, ex.Message);
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unable to process image url."));
}
}
return(req.CreateResponse(HttpStatusCode.OK));
}
public async void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
log.LogInformation(eventGridEvent.Data.ToString());
if (adtInstanceUrl == null)
{
log.LogError("Application setting \"ADT_SERVICE_URL\" not set");
}
try
{
//Authenticate with Digital Twins
ManagedIdentityCredential cred = new ManagedIdentityCredential("https://digitaltwins.azure.net");
DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), cred, new DigitalTwinsClientOptions {
Transport = new HttpClientTransport(httpClient)
});
log.LogInformation($"ADT service client connection created.");
if (eventGridEvent != null && eventGridEvent.Data != null)
{
log.LogInformation(eventGridEvent.Data.ToString());
// Reading deviceId and temperature for IoT Hub JSON
JObject deviceMessage = (JObject)JsonConvert.DeserializeObject(eventGridEvent.Data.ToString());
string deviceId = (string)deviceMessage["systemProperties"]["iothub-connection-device-id"];
string deviceType = (string)deviceMessage["body"]["DeviceType"];
log.LogInformation($"Device:{deviceId} DeviceType is:{deviceType}");
switch (deviceType)
{
case "Gearbox":
var gearboxPayload = new Dictionary <string, int>
{
["GearInjNozzleTemp"] = deviceMessage["body"]["GearInjNozzleTemp"].Value <int>(),
["GearPump2Rpm"] = deviceMessage["body"]["GearPump2Rpm"].Value <int>(),
["GearLubricationPressure"] = deviceMessage["body"]["GearLubricationPressure"].Value <int>(),
["GearOilPressure"] = deviceMessage["body"]["GearOilPressure"].Value <int>(),
["GearOilTankLevel"] = deviceMessage["body"]["GearOilTankLevel"].Value <int>()
};
await client.PublishTelemetryAsync(deviceId, Guid.NewGuid().ToString(), JsonConvert.SerializeObject(gearboxPayload));
log.LogInformation($"Published component telemetry message to twin '{deviceId}'.");
break;
case "Generator":
var generatorPayload = new Dictionary <string, int>
{
["generatingVoltage"] = deviceMessage["body"]["generatingVoltage"].Value <int>(),
["generatingPower"] = deviceMessage["body"]["generatingPower"].Value <int>(),
["GeneratorCableTemp"] = deviceMessage["body"]["GeneratorCableTemp"].Value <int>(),
["GeneratorFanMotorRpm"] = deviceMessage["body"]["GeneratorFanMotorRpm"].Value <int>(),
["GeneratorRpm"] = deviceMessage["body"]["GeneratorRpm"].Value <int>(),
["GeneratorWaterTemp"] = deviceMessage["body"]["GeneratorWaterTemp"].Value <int>(),
["GeneratorWaterOutPressure"] = deviceMessage["body"]["GeneratorWaterOutPressure"].Value <int>(),
["WindingL1Inv1Temp"] = deviceMessage["body"]["WindingL1Inv1Temp"].Value <int>(),
["WindingL2Inv1Temp"] = deviceMessage["body"]["WindingL2Inv1Temp"].Value <int>(),
["WindingL3Inv1Temp"] = deviceMessage["body"]["WindingL3Inv1Temp"].Value <int>()
};
await client.PublishTelemetryAsync(deviceId, Guid.NewGuid().ToString(), JsonConvert.SerializeObject(generatorPayload));
log.LogInformation($"Published component telemetry message to twin '{deviceId}'.");
break;
}
}
}
catch (Exception e)
{
log.LogError(e.Message);
}
}
public void TestEventGridToNuget_Single([EventGridTrigger] EventGridEvent value)
{
_functionOut = value.Subject;
Assert.IsNotNull(value.Data);
}
public static void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
log.LogInformation(eventGridEvent.Data.ToString());
}
public static async Task RunAsync([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
//Extracting content type and url of the blob triggering the function
var jsondata = JsonConvert.SerializeObject(eventGridEvent.Data);
var tmp = new { contentType = "", url = "" };
var data = JsonConvert.DeserializeAnonymousType(jsondata, tmp);
//Checking if the trigger was iniatiated for a WAV File.
if (data.contentType == "audio/wav")
{
var audioUrl = data.url;
string blobName = audioUrl.Split('/').Last();
string contosoStorageConnectionString = System.Environment.GetEnvironmentVariable("ContosoStorageConnectionString", EnvironmentVariableTarget.Process);
string speechRegion = System.Environment.GetEnvironmentVariable("SpeechRegion", EnvironmentVariableTarget.Process);
string speechKey = System.Environment.GetEnvironmentVariable("SpeechKey", EnvironmentVariableTarget.Process);
string translatorKey = System.Environment.GetEnvironmentVariable("TranslatorKey", EnvironmentVariableTarget.Process);
string translatorEndpoint = System.Environment.GetEnvironmentVariable("TranslatorEndpoint", EnvironmentVariableTarget.Process);
string translatorLocation = System.Environment.GetEnvironmentVariable("TranslatorLocation", EnvironmentVariableTarget.Process);
string cosmosEndpointUrl = System.Environment.GetEnvironmentVariable("CosmosDBEndpointUrl", EnvironmentVariableTarget.Process);
string cosmosPrimaryKey = System.Environment.GetEnvironmentVariable("CosmosDBPrimaryKey", EnvironmentVariableTarget.Process);
string textAnalyticsKey = System.Environment.GetEnvironmentVariable("TextAnalyticsKey", EnvironmentVariableTarget.Process);
string textAnalyticsEndpoint = System.Environment.GetEnvironmentVariable("TextAnalyticsEndpoint", EnvironmentVariableTarget.Process);
// Download audio file to a local temp directory
var tempPath = System.IO.Path.GetTempFileName();
BlobContainerClient container = new BlobContainerClient(contosoStorageConnectionString, "audiorecordings");
BlobClient blob = container.GetBlobClient(blobName);
await blob.DownloadToAsync(tempPath);
var speechConfig = SpeechConfig.FromSubscription(speechKey, speechRegion);
speechConfig.SetProperty(PropertyId.SpeechServiceConnection_SingleLanguageIdPriority, "Latency");
// Audio Language Identification
// Considering only two languages: English and Spanish
// Languages supported for language detection : https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support
var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromLanguages(new string[] { "en-US", "es-MX" });
string languageDetected = "en-US";
using (var audioInput = AudioConfig.FromWavFileInput(tempPath))
{
using (var recognizer = new SourceLanguageRecognizer(speechConfig, autoDetectSourceLanguageConfig, audioInput))
{
var result = await recognizer.RecognizeOnceAsync().ConfigureAwait(false);
if (result.Reason == ResultReason.RecognizedSpeech)
{
var lidResult = AutoDetectSourceLanguageResult.FromResult(result);
languageDetected = lidResult.Language;
}
}
}
speechConfig.SpeechRecognitionLanguage = languageDetected;
// Audio Transcription
StringBuilder sb = new StringBuilder();
using var audioConfig = AudioConfig.FromWavFileInput(tempPath);
{
using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
{
var stopRecognition = new TaskCompletionSource <int>();
recognizer.SessionStopped += (s, e) =>
{
stopRecognition.TrySetResult(0);
};
recognizer.Canceled += (s, e) =>
{
stopRecognition.TrySetResult(0);
};
recognizer.Recognized += (s, e) =>
{
if (e.Result.Reason == ResultReason.RecognizedSpeech)
{
sb.Append(e.Result.Text);
}
else if (e.Result.Reason == ResultReason.NoMatch)
{
log.LogInformation($"NOMATCH: Speech could not be recognized.");
}
};
await recognizer.StartContinuousRecognitionAsync();
Task.WaitAny(new[] { stopRecognition.Task });
}
}
string transcribedText = sb.ToString();
// If transcription is in Spanish we will translate it to English
if (!languageDetected.Contains("en"))
{
string route = $"/translate?api-version=3.0&to=en";
string textToTranslate = sb.ToString();
object[] body = new object[] { new { Text = textToTranslate } };
var requestBody = JsonConvert.SerializeObject(body);
using (var client = new HttpClient())
using (var request = new HttpRequestMessage())
{
request.Method = HttpMethod.Post;
request.RequestUri = new Uri(translatorEndpoint + route);
request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
request.Headers.Add("Ocp-Apim-Subscription-Key", translatorKey);
request.Headers.Add("Ocp-Apim-Subscription-Region", translatorLocation);
HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
var responseBody = await response.Content.ReadAsStringAsync();
List <Model.TranslatorService.Root> translatedDocuments = JsonConvert.DeserializeObject <List <Model.TranslatorService.Root> >(responseBody);
transcribedText = translatedDocuments.FirstOrDefault().Translations.FirstOrDefault().Text;
}
}
//TODO:Azure Text Analytics for Healthcare
//Insert documents into CosmosDB
var cosmosClient = new CosmosClient(cosmosEndpointUrl, cosmosPrimaryKey);
var cosmosDatabase = (await cosmosClient.CreateDatabaseIfNotExistsAsync("Contoso")).Database;
var cosmosContainer = (await cosmosDatabase.CreateContainerIfNotExistsAsync("Transcriptions", "/id")).Container;
Model.Transcription newTranscription = new Model.Transcription();
newTranscription.Id = Guid.NewGuid().ToString();
newTranscription.DocumentDate = new DateTime(int.Parse(blobName.Substring(0, 4)),
int.Parse(blobName.Substring(4, 2)), int.Parse(blobName.Substring(6, 2)));
newTranscription.FileName = blobName;
newTranscription.TranscribedText = transcribedText;
foreach (var item in healthcareResult.Entities)
{
newTranscription.HealthcareEntities.Add(new Model.HealthcareEntity()
{
Category = item.Category, Text = item.Text
});
}
try
{
ItemResponse <Model.Transcription> cosmosResponse = await
cosmosContainer.CreateItemAsync(newTranscription, new PartitionKey(newTranscription.Id));
}
catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.Conflict)
{
//Conflicting documents are silently ignored for demo purposes.
}
System.IO.File.Delete(tempPath);
log.LogInformation(eventGridEvent.Data.ToString());
}
}
public static bool TryGetValue(this EventGridEvent gridEvent, string key, out object value)
{
var retval = false;
value = null;
if (!string.IsNullOrWhiteSpace(key))
{
switch (key)
{
case nameof(gridEvent.Id):
value = gridEvent.Id;
retval = true;
break;
case nameof(gridEvent.Topic):
value = gridEvent.Topic;
retval = true;
break;
case nameof(gridEvent.Subject):
value = gridEvent.Subject;
retval = true;
break;
case nameof(gridEvent.EventType):
value = gridEvent.EventType;
retval = true;
break;
case nameof(gridEvent.DataVersion):
value = gridEvent.DataVersion;
retval = true;
break;
case nameof(gridEvent.Data):
value = gridEvent.Data;
retval = true;
break;
default:
var split = key.Split('.');
if (split[0] == (nameof(gridEvent.Data)) && gridEvent.Data != null && split.Length > 1)
{
var tmpValue = gridEvent.Data;
for (int i = 0; i < split.Length; i++)
{
// look for the property on the grid event data object
if (JObject.FromObject(tmpValue).TryGetValue(split[i], out var dataValue))
{
tmpValue = dataValue.ToObject <object>();
if (i == split.Length - 1)
{
retval = true;
value = tmpValue;
}
}
}
}
break;
}
}
return(retval);
}
public static async Task OnGetLeagueSummaryQueryHandler(
[EventGridTrigger] EventGridEvent eventGridEvent,
[OrchestrationClient] DurableOrchestrationClient getLeagueSummaryQueryHandlerOrchestrationClient,
Microsoft.Extensions.Logging.ILogger log
)
{
#region Logging
if (null != log)
{
log.LogDebug("Function triggered in OnGetLeagueSummaryQuery");
}
if (null == eventGridEvent)
{
// This function should not proceed if there is no event data
if (null != log)
{
log.LogError("Missing event grid trigger data in OnGetLeagueSummaryQuery");
}
return;
}
else
{
if (null != log)
{
log.LogDebug($"Event grid topic: {eventGridEvent.Topic}");
log.LogDebug($"Event grid subject: {eventGridEvent.Subject }");
log.LogDebug($"Event grid metadata version: {eventGridEvent.MetadataVersion }");
log.LogDebug($"Event grid event type: {eventGridEvent.EventType }");
log.LogDebug($"Event Grid Data : {eventGridEvent.Data }");
}
}
#endregion
try
{
#region Logging
if (null != log)
{
log.LogDebug($"Get the query parameters in OnGetLeagueSummaryQuery");
if (null == eventGridEvent.Data)
{
log.LogError($"The query parameter has no values in OnGetLeagueSummaryQuery");
return;
}
}
#endregion
// Get the query request details out of the event grid data request
var jsondata = JsonConvert.SerializeObject(eventGridEvent.Data);
QueryRequest <Get_League_Summary_Definition> queryRequest = null;
if (!string.IsNullOrWhiteSpace(jsondata))
{
queryRequest = JsonConvert.DeserializeObject <QueryRequest <Get_League_Summary_Definition> >(jsondata);
}
if (null != queryRequest)
{
if (null != log)
{
log.LogInformation($"Running query handler with durable functions orchestration");
log.LogInformation($"{queryRequest.QueryName} with league {queryRequest.GetParameters().League_Name}");
}
// Using Azure Durable functions to do the query chaining
string instanceId = await getLeagueSummaryQueryHandlerOrchestrationClient.StartNewAsync("OnGetLeagueSummaryQueryHandlerOrchestrator", queryRequest);
if (null != log)
{
log.LogInformation($"Started OnGetLeagueSummaryQueryHandlerOrchestrator orchestration with ID = '{instanceId}'.");
}
var status = await getLeagueSummaryQueryHandlerOrchestrationClient.GetStatusAsync(instanceId);
if (null != log)
{
log.LogInformation($"Orchestration '{instanceId}' has status {status.RuntimeStatus} : {status.Output}.");
}
}
else
{
if (null != log)
{
log.LogError($"Unable to read query request from eventgrid data: {eventGridEvent.Data} Type: {eventGridEvent.Data.GetType()} ");
}
}
}
catch (Exception ex)
{
if (null != log)
{
log.LogError(ex.ToString(), ex);
}
throw;
}
}
public static async Task ProcessTripExternalizations2SignalR([EventGridTrigger] EventGridEvent eventGridEvent,
[SignalR(HubName = "trips")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
log.LogInformation($"ProcessTripExternalizations2SignalR triggered....EventGridEvent" +
$"\n\tId:{eventGridEvent.Id}" +
$"\n\tTopic:{eventGridEvent.Topic}" +
$"\n\tSubject:{eventGridEvent.Subject}" +
$"\n\tType:{eventGridEvent.EventType}" +
$"\n\tData:{eventGridEvent.Data}");
try
{
TripItem trip = JsonConvert.DeserializeObject <TripItem>(eventGridEvent.Data.ToString());
if (trip == null)
{
throw new Exception("Trip is null!");
}
log.LogInformation($"ProcessTripExternalizations2SignalR trip code {trip.Code}");
// Convert the `event subject` to a method to be called on clients
var clientMethod = "tripUpdated";
if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_DRIVERS_NOTIFIED)
{
clientMethod = "tripDriversNotified";
}
else if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_DRIVER_PICKED)
{
clientMethod = "tripDriverPicked";
}
else if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_STARTING)
{
clientMethod = "tripStarting";
}
else if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_RUNNING)
{
clientMethod = "tripRunning";
}
else if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_COMPLETED)
{
clientMethod = "tripCompleted";
}
else if (eventGridEvent.Subject == Constants.EVG_SUBJECT_TRIP_ABORTED)
{
clientMethod = "tripAborted";
}
log.LogInformation($"ProcessTripExternalizations2SignalR firing SignalR `{clientMethod}` client method!");
await signalRMessages.AddAsync(new SignalRMessage()
{
Target = clientMethod,
Arguments = new object[] { trip }
});
}
catch (Exception e)
{
var error = $"ProcessTripExternalizations2SignalR failed: {e.Message}";
log.LogError(error);
throw e;
}
}
public static void Run([EventGridTrigger] EventGridEvent eventGridEvent, TraceWriter log)
#endif
{
log.Info(eventGridEvent.Data.ToString());
}
