public async Task Run([TimerTrigger("0 0 * * * *")] MyInfo myTimer, FunctionContext context)
{
var log = context.GetLogger("UserNotifier");
log.LogInformation($"UserNotifier trigger function executed at: {DateTime.Now}");
await userNotificationManager.RunAllNotificatons().ConfigureAwait(false);
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestData req, FunctionContext functionContext)
{
var logger = functionContext.GetLogger(nameof(GetGitHubClientId));
logger.LogInformation("Retrieving Organizations Url");
if (string.IsNullOrWhiteSpace(_enableOrganizationsUrl))
{
var notFoundResponse = req.CreateResponse(System.Net.HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync("Enable Organizations Url Not Found").ConfigureAwait(false);
return(notFoundResponse);
}
if (string.IsNullOrWhiteSpace(GetGitHubClientId.ClientId))
{
var notFoundResponse = req.CreateResponse(System.Net.HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync("Client Id Not Found").ConfigureAwait(false);
return(notFoundResponse);
}
var okResponse = req.CreateResponse(System.Net.HttpStatusCode.OK);
var getGitTrendsEnableOrganizationsUri = JsonConvert.SerializeObject(new GitTrendsEnableOrganizationsUriDTO(new Uri(_enableOrganizationsUrl + GetGitHubClientId.ClientId)));
await okResponse.WriteStringAsync(getGitTrendsEnableOrganizationsUri).ConfigureAwait(false);
return(okResponse);
}
public static async Task <object> RunAsync(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("Messages");
logger.LogInformation("C# HTTP trigger function processed a request.");
var message = await req.ReadFromJsonAsync <FireMessage>();
var game = CosmosDbHandler.FindGame(message?.GameId, logger);
if (game == null)
{
return(null);
}
game = GameController.Fire(game, message.PlayerId, message.Row, message.Column);
game = await CosmosDbHandler.SaveGameAsync(game, logger);
return(new
{
Target = "gameUpdated",
Arguments = new Game[]
{
game
}
});
}
public async Task Run(
[ServiceBusTrigger(
"%QueueListenerNameForDequeue%",
Connection = "ServiceBusConnectionString")]
byte[] message,
FunctionContext context)
{
var logger = context.GetLogger("ReplyToRequestFromPostOffice");
logger.LogInformation("C# ServiceBus ReplyToDequeueFromPostOffice triggered");
try
{
var dequeueNotification = _dequeueNotificationParser.Parse(message);
var dataAvailableNotificationIds = await _storageHandler
.GetDataAvailableNotificationIdsAsync(dequeueNotification)
.ConfigureAwait(false);
logger.LogInformation($"Dequeue received for {dequeueNotification.MarketOperator.Value} with notification ids: {string.Join(",", dataAvailableNotificationIds)}");
}
catch (Exception e)
{
throw new InvalidOperationException("Could not process message.", e);
}
}
public static void Run([TimerTrigger("0 */5 * * * *")] MyInfo timerInfo,
FunctionContext context)
{
var logger = context.GetLogger("TimerFunction");
logger.LogInformation($"Function Ran. Next timer schedule = {timerInfo.ScheduleStatus.Next}");
}
public async Task Run(
[KafkaTrigger("KAFKA_BROKERS", "input-to-process-profile-page", ConsumerGroup = "input-processor-group")]
KafkaMessage ev,
FunctionContext context)
{
var logger = context.GetLogger("ProfilePageGeneratorFunc");
logger.LogInformation($"Start ProfilePageGeneratorFunc");
var msg = JsonSerializer.Deserialize <InputToProcessEvent>(ev.Value);
if (msg is null)
{
logger.LogError($"value of event is empty | timestamp: {ev.Timestamp}");
return;
}
var storageClient = new MinioClient(MinioEndpoint, MinioAccessKey, MinioSecretKey);
// 1, Download input file from S3 bucket (minio)
var input = await DownloadInputData(logger, storageClient, msg.bucketName, msg.objectName);
logger.LogInformation($"processing {input.template} input");
// 2. Download html template from s3 repo (should sync by other periodic function)
var template = await GetTemplate(input.template);
// 3. Combine these two sources into one html file
var output = GenerateOutput(input.data, template);
// 4. Put generated file to the S3
await UploadGeneratedOutput(storageClient, output, input.template);
logger.LogInformation($"end ProfilePageGeneratorFunc");
}
public async Task CampaignCreatedHandler(
[QueueTrigger("%ENVIRONMENT%-" + QueueNames.CampaignCreated, Connection = "StorageConnection")] string message,
FunctionContext executionContext
)
{
var logger = executionContext.GetLogger(FunctionNames.CampaignCreated);
logger.LogInformation("Function '{FunctionName}' was triggered.", FunctionNames.CampaignCreated);
var campaign = JsonSerializer.Deserialize <CampaignQueueItem>(message, JsonSerializerOptionDefaults.GetDefaultSettings());
if (!campaign.Published)
{
return;
}
if (campaign.DeliveryChannel.HasFlag(CampaignQueueItem.CampaignDeliveryChannel.PushNotification))
{
await ProcessPushNotifications(campaign);
return;
}
if (campaign.DeliveryChannel.HasFlag(CampaignQueueItem.CampaignDeliveryChannel.Email))
{
// TODO: Create next hop to send campaign via email.
return;
}
if (campaign.DeliveryChannel.HasFlag(CampaignQueueItem.CampaignDeliveryChannel.SMS))
{
// TODO: Create next hop to send campaign via SMS gateway.
return;
}
}
public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
{
var logger = context.GetLogger <AuthenticationMiddleware>();
var data = context.BindingContext.BindingData;
if (data.ContainsKey("Headers"))
{
data.TryGetValue("Headers", out var headersObject);
var headers = JsonSerializer.Deserialize <JsonDocument>(headersObject as string);
var authzHeaderExists = headers.RootElement.TryGetProperty("Authorization", out JsonElement authorizationHeader);
if (authzHeaderExists)
{
var token = authorizationHeader.ToString().Substring("Bearer ".Length);
var principal = await _authenticationProvider.AuthenticateAsync(context, token);
if (principal != null)
{
await next(context);
return;
}
}
}
// return 401
}
public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("HttpExample");
logger.LogInformation("C# HTTP trigger function processed a request.");
var message = "Welcome to Azure Functions!";
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
response.WriteString(message);
// Return a response to both HTTP trigger and Azure Cosmos DB output binding.
return(new MultiResponse()
{
Document = new MyDocument
{
id = System.Guid.NewGuid().ToString(),
message = message
},
HttpResponse = response
});
}
public static void Run([BlobTrigger("reproerrorazbt/{name}", Connection = "nicocsetrips_STORAGE")] Stream myBlob, string name,
FunctionContext context)
{
var logger = context.GetLogger("BlobTriggerCSharpError");
logger.LogInformation($"C# Blob trigger function Processed blob\n Name: {name} \n Data: {myBlob}");
}
public async Task Run(
[EventHubTrigger(
"client-events",
Connection = "clientEventsListenerEventHubConnectionString",
ConsumerGroup = "client-events-processing-consumer-group")] TrainEvent[] input,
FunctionContext context)
{
await _trainEventsRepository.StoreAsync(input);
// calculate regular behavior
foreach (var trainEvent in input)
{
var all = _trainEventsRepository.GetEventsByVehicleAndOrderAsync(
trainEvent.VehicleId,
trainEvent.OrderNumberCurrent);
var list = new List<int>();
await foreach (var e in all)
{
list.Add(e.
}
}
//
var logger = context.GetLogger("IngressEventHub");
logger.LogInformation($"First Event Hubs triggered message: {input[0]}");
}
public async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
FunctionContext executionContext)
{
var log = executionContext.GetLogger <Function1>();
log.LogInformation("C# HTTP trigger function processed a request.");
var query = HttpUtility.ParseQueryString(req.Url.Query);
string name = query["name"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
string responseMessage = string.IsNullOrEmpty(name)
? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
: $"Hello, {name}. This HTTP triggered function executed successfully.";
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content", "Content-Type: text/html; charset=utf-8");
response.WriteString(responseMessage);
return(response);
}
public TestData QueueTriggerAndOutputPoco(
[QueueTrigger("test-input-dotnet-isolated-poco")] TestData message,
FunctionContext context)
{
context.GetLogger <QueueTestFunctions>().LogInformation(".NET Queue trigger POCO function processed a message: " + message.Id);
return(message);
}
public async Task <IReadOnlyList <AdvocateModel> > GetAzureAdvocatesTimerTrigger([TimerTrigger(_runOncePerMonth)] TimerInfo myTimer, FunctionContext context)
{
var log = context.GetLogger <GetAdvocatesFunction>();
log.LogInformation($"{nameof(GetAzureAdvocatesTimerTrigger)} Started");
var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var optOutList = await _optOutDatabase.GetAllOptOutModels().ConfigureAwait(false);
var currentAdvocateList = await _advocateService.GetCurrentAdvocates(cancellationTokenSource.Token).ConfigureAwait(false);
var advocateModels = new List <AdvocateModel>();
foreach (var advocate in currentAdvocateList)
{
if (!HasUserOptedOut(advocate, optOutList))
{
advocateModels.Add(advocate);
}
}
log.LogInformation($"{nameof(GetAzureAdvocatesTimerTrigger)} Completed");
return(advocateModels);
}
public async Task <HttpResponseData> GetCourseDirectoryQualificationJson(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequestData request,
FunctionContext functionContext)
{
var logger = functionContext.GetLogger("HttpFunction");
try
{
logger.LogInformation("Course directory GetCourseDirectoryQualificationJson function was called.");
var json = await _courseDirectoryDataService.GetTLevelQualificationJsonFromCourseDirectoryApi();
var response = request.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/json");
await response.WriteStringAsync(json);
return(response);
}
catch (Exception e)
{
var errorMessage = $"Error reading json data from course directory. Internal Error Message {e}";
logger.LogError(errorMessage);
return(request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public static async Task Run([ServiceBusTrigger(
"<your_queue_name>",
Connection = "QueueConnectionString")]
byte[] item,
Int32 deliveryCount,
DateTime enqueuedTimeUtc,
string messageId,
IDictionary <string, object> UserProperties,
FunctionContext context)
{
var logger = context.GetLogger("ServiceBusFunction");
logger.LogInformation($"MessageID: {messageId}");
FunctionInputData functionInputData = new FunctionInputData(item, messageId, UserProperties);
var settings =
new StorageSettingData(
"<your_blob_storage_container_name>",
"<your_blob_storage_connection_string>",
VeryLargeMessageStrategy.Storage);
FunctionMessageReader reader = new FunctionMessageReader(settings);
await reader.SubScribe(functionInputData,
(arg) =>
{
//PUT HERE YOUR MESSAGE HANDLING LOGIC
logger.LogInformation($"function processed object: {arg.ReceivedEventMessage?.ObjectName??arg.ReceivedEventMessage.Body.Substring(0,10)}");
});
return;
}
public async Task <HttpResponseData> ManualImport(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequestData request,
FunctionContext functionContext)
{
var logger = functionContext.GetLogger("HttpFunction");
try
{
logger.LogInformation("Course directory manual import function was called.");
var(savedProviders, deletedProviders, savedQualifications, deletedQualifications) = await Import(logger);
logger.LogInformation("Course directory manual import finished.");
var response = request.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/text");
await response.WriteStringAsync(
$"Inserted or updated {savedProviders} and deleted {deletedProviders} providers.\r\n" +
$"Inserted or updated {savedQualifications} and deleted {deletedQualifications} qualifications.");
return(response);
}
catch (Exception e)
{
var errorMessage = $"Error importing data from course directory. Internal Error Message {e}";
logger.LogError(errorMessage);
return(request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req, FunctionContext context)
{
var log = context.GetLogger(nameof(GetAppCenterApiKeys));
log.LogInformation("Retrieving Client Id");
if (string.IsNullOrWhiteSpace(_iOS))
{
var notFoundResponse = req.CreateResponse(HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync($"{nameof(_iOS)} Not Found").ConfigureAwait(false);
return(notFoundResponse);
}
else if (string.IsNullOrWhiteSpace(_android))
{
var notFoundResponse = req.CreateResponse(HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync($"{nameof(_android)} Not Found").ConfigureAwait(false);
return(notFoundResponse);
}
else
{
var response = req.CreateResponse(HttpStatusCode.OK);
var appCenterApiKeyDtoJson = JsonConvert.SerializeObject(new AppCenterApiKeyDTO(_iOS, _android));
await response.WriteStringAsync(appCenterApiKeyDtoJson).ConfigureAwait(false);
return(response);
}
}
public async Task <HttpResponseData> Blob(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequestData req,
[BlobInput("samples/Sample.mp4", Connection = "AzureWebJobsStorage")] Stream sample,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("HttpFunction");
logger.LogInformation("message logged");
var blobContainerClient = blobServiceClient.GetBlobContainerClient("test");
await blobContainerClient.CreateIfNotExistsAsync();
var blobClient = blobContainerClient.GetBlobClient("sample.mp4");
var stopwatch = new Stopwatch();
stopwatch.Start();
await blobClient.UploadAsync(sample);
stopwatch.Stop();
var response = req.CreateResponse(HttpStatusCode.OK);
var buffer = Encoding.UTF8.GetBytes(stopwatch.ElapsedMilliseconds.ToString());
await response.Body.WriteAsync(buffer, 0, buffer.Length);
return(response);
}
/// <inheritdoc/>
public async Task <HttpResponseData> RenderOpenApiDocument(HttpRequestData req, string version, string extension, FunctionContext ctx)
{
var log = ctx.GetLogger(nameof(OpenApiTriggerFunction));
log.LogInformation($"{version}.{extension} was requested.");
var fi = new FileInfo(ctx.FunctionDefinition.PathToAssembly);
var request = new HttpRequestObject(req);
var result = default(string);
var response = default(HttpResponseData);
try
{
var auth = await this._context
.SetApplicationAssemblyAsync(fi.Directory.FullName, appendBin : false)
.AuthorizeAsync(request)
.ConfigureAwait(false);
if (!auth.IsNullOrDefault())
{
response = req.CreateResponse(auth.StatusCode);
response.Headers.Add("Content-Type", auth.ContentType);
await response.WriteStringAsync(auth.Payload).ConfigureAwait(false);
return(response);
}
result = await this._context
.Document
.InitialiseDocument()
.AddMetadata(this._context.OpenApiConfigurationOptions.Info)
.AddServer(request, this._context.HttpSettings.RoutePrefix, this._context.OpenApiConfigurationOptions)
.AddNamingStrategy(this._context.NamingStrategy)
.AddVisitors(this._context.GetVisitorCollection())
.Build(this._context.ApplicationAssembly, this._context.GetOpenApiVersionType(version))
.ApplyDocumentFilters(this._context.GetDocumentFilterCollection())
.RenderAsync(this._context.GetOpenApiSpecVersion(version), this._context.GetOpenApiFormat(extension))
.ConfigureAwait(false);
response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", this._context.GetOpenApiFormat(extension).GetContentType());
await response.WriteStringAsync(result).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError(ex.Message);
result = ex.Message;
if (this._context.IsDevelopment)
{
result += "\r\n\r\n";
result += ex.StackTrace;
}
response = req.CreateResponse(HttpStatusCode.InternalServerError);
response.Headers.Add("Content-Type", ContentTypeText);
await response.WriteStringAsync(result).ConfigureAwait(false);
}
return(response);
}
public async Task SendPushNotificationHandler(
[QueueTrigger("%ENVIRONMENT%-" + QueueNames.SendPushNotification, Connection = "StorageConnection")] string message,
FunctionContext executionContext
)
{
var logger = executionContext.GetLogger(FunctionNames.SendPushNotification);
logger.LogInformation("Function '{FunctionName}' was triggered.", FunctionNames.SendPushNotification);
var pushNotification = JsonSerializer.Deserialize <PushNotificationQueueItem>(message, JsonSerializerOptionDefaults.GetDefaultSettings());
var data = pushNotification.Campaign?.Data ?? new ExpandoObject();
var dataDictionary = data as IDictionary <string, object>;
if (!dataDictionary.ContainsKey("id"))
{
data.TryAdd("id", pushNotification.Campaign.Id);
}
if (pushNotification.Broadcast)
{
await PushNotificationService.BroadcastAsync(pushNotification.Campaign.Title, pushNotification.Campaign.Content, data, pushNotification.Campaign?.Type?.Name);
}
else
{
await PushNotificationService.SendAsync(pushNotification.Campaign.Title, pushNotification.Campaign.Content, data, pushNotification.UserCode, classification : pushNotification.Campaign?.Type?.Name);
}
}
public async Task RunAsync(
[ServiceBusTrigger("%QueueListenerName%", Connection = "ServiceBusConnectionString", IsSessionsEnabled = true)]
byte[] message,
FunctionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var logger = context.GetLogger("ReplyToRequestFromPostOffice");
logger.LogInformation($"C# ServiceBus queue trigger function processesing message: {message}");
try
{
var bundleRequestDto = _requestBundleParser.Parse(message);
var requestDataBundleResponseDto = await CreateResponseAsync(bundleRequestDto).ConfigureAwait(false);
await _responseSender.SendAsync(requestDataBundleResponseDto).ConfigureAwait(false);
}
catch (MessageHubStorageException e)
{
logger.LogError("Error Processing message: {0}", e);
throw;
}
}
public async Task <SubmissionResponse> Submit([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "markers")] HttpRequestData req,
FunctionContext context)
{
var logger = context.GetLogger("submit-markers");
using var streamReader = new StreamReader(req.Body);
var submission = streamReader.ReadToEnd().Deserialize <MarkerSubmissionDto>();
if (string.IsNullOrEmpty(submission.Name) || string.IsNullOrEmpty(submission.Description))
{
return(new SubmissionResponse
{
Response = req.CreateResponse(HttpStatusCode.BadRequest)
});
}
string fileHandle = null;
if (!string.IsNullOrEmpty(submission.Base64Image))
{
var fileBytes = Convert.FromBase64String(submission.Base64Image);
fileHandle = await imageStorageService.UploadFileAndGetHandle(fileBytes);
}
var pending = await markersService.AddMarkerSubmission(submission, fileHandle);
logger.LogInformation($"DeepLinkBaseUrl: {pending.DeepLinkBaseUrl}");
return(new SubmissionResponse
{
QueueMessage = pending,
Response = req.CreateResponse(HttpStatusCode.OK)
});
}
public async Task InsertIntoLeaderboard(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger <LeaderboardFunction>();
logger.LogInformation("Insert Into Leaderboard");
try
{
var e = await req.Deserialize <BoardEntry>();
var board = new Board {
UserId = e.UserId, NumOfWorkouts = e.NumOfWorkouts
};
var boardUser = new BoardUser
{
UserId = e.UserId,
Email = e.Email,
LastWorkout = e.LastWorkout,
Name = e.Name
};
board.User = boardUser;
_d.Store.Boards.Add(board);
await _d.Store.SaveChangesAsync();
}
catch (Exception ex)
{
logger.LogError(ex, nameof(InsertIntoLeaderboard));
throw;
}
}
public async Task Run(
[KafkaTrigger("KAFKA_BROKERS", "minio-events-inputs", ConsumerGroup = "input-processor-group")]
KafkaMessage ev,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("InputProcessorFunc");
logger.LogInformation("InputProcessorFunc start");
var minioEvent = JsonSerializer.Deserialize <S3ObjectEvent>(ev.Value);
switch (minioEvent.EventName)
{
case "s3:ObjectRemoved:Delete":
logger.LogInformation($"deleted {minioEvent.Key}");
break;
case "s3:ObjectCreated:Put":
{
await InputObjectCreated(logger, minioEvent);
break;
}
default:
logger.LogInformation($"no executor for {minioEvent.EventName}");
break;
}
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("Post");
logger.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
Tarefa obj = JsonConvert.DeserializeObject <Tarefa>(requestBody);
var repositorio = new TarefaRepositorio();
var okRetorno = req.CreateResponse();
if (obj == null)
{
await okRetorno.WriteAsJsonAsync(new BadRequestObjectResult(new { message = "Dados para criação de uma tarefa é obrigatoria" }));
}
else
{
obj.Id = Guid.NewGuid();
obj.DtCreate = DateTime.UtcNow;
await repositorio.Save(obj);
await okRetorno.WriteAsJsonAsync(new CreatedResult("", obj));
}
return(okRetorno);
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestData req,
FunctionContext executionContext)
{
var repositorio = new TarefaRepositorio();
var okRetorno = req.CreateResponse();
var logger = executionContext.GetLogger("GetById");
Tarefa tarefa = new();
logger.LogInformation("C# HTTP trigger function processed a request.");
var query = System.Web.HttpUtility.ParseQueryString(req.Url.Query);
var value = query["id"];
if (value != null)
{
tarefa = repositorio.GetById(new Guid(value));
if (tarefa == null)
{
okRetorno = req.CreateResponse(System.Net.HttpStatusCode.NotFound);
}
else
{
await okRetorno.WriteAsJsonAsync(new OkObjectResult(tarefa));
}
}
else
{
okRetorno = req.CreateResponse(System.Net.HttpStatusCode.BadRequest);
}
return(okRetorno);
}
public async Task <HttpResponseData> RunHttpTrigger([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req, FunctionContext executionContext)
{
var logger = executionContext.GetLogger("HttpTrigger");
var principal = await _authentication.AuthenticateAsync(executionContext, req);
if (principal == null)
{
return(_authentication.ReplyUnauthorized(req));
}
var microsoftGraph = new GraphServiceClient(new DelegateAuthenticationProvider(async(request) =>
{
var token = await _authentication.GetAccessTokenForUserAsync(req, new string[] { "https://graph.microsoft.com/.default" });
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
}));
var name = principal.Claims.Where(x => x.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name").First().Value;
logger.LogInformation($"User is {name}!");
var inbox = await microsoftGraph.Me.MailFolders.Inbox.Request().GetAsync();
logger.LogInformation($"{name} has {inbox.UnreadItemCount} unread e-mails!");
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
response.WriteString($"Welcome to Azure Functions Out-Of-Process, {name}!\n\nYou have {inbox.UnreadItemCount} unread e-mails!");
return(response);
}
public async Task <PlaceOrderOutputType> OrderProductV2Async([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("ProductFunctions");
logger.LogInformation("Order Product is called");
var output = new PlaceOrderOutputType();
var order = await req.ReadFromJsonAsync <ProductOrder>();
var p = ProductStore.Products.FirstOrDefault(x => x.Name == order.Name);
if (p != null)
{
logger.LogInformation("Product found, sending message");
output.HttpResponse = req.CreateResponse(HttpStatusCode.OK);
output.Order = new PlaceOrder
{
OrderId = Guid.NewGuid().ToString(),
Product = p,
Buyer = order.Buyer
};
}
else
{
logger.LogWarning("Product not found");
output.HttpResponse = req.CreateResponse(HttpStatusCode.NotFound);
}
return(output);
}
public async Task Run([TimerTrigger("0 0 0 */1 * *")] MyInfo myTimer, FunctionContext context)
{
var log = context.GetLogger("HttpExample");
log.LogInformation($"Getting Stats trigger function executed at: {DateTime.Now}");
var connectionString = Environment.GetEnvironmentVariable("TMDBServerConnectionString");
var sendGridApiKey = Environment.GetEnvironmentVariable("SendGridApiKey");
var instanceName = Environment.GetEnvironmentVariable("InstanceName");
var siteStats = new SiteStats();
using (var conn = new SqlConnection(connectionString))
{
conn.Open();
siteStats.UserCount = await CountUsers(log, conn).ConfigureAwait(false);
siteStats.EventCount = await CountEvents(log, conn).ConfigureAwait(false);
siteStats.AttendeeCount = await CountEventAttendees(log, conn).ConfigureAwait(false);
siteStats.FutureEventsCount = await CountFutureEvents(log, conn).ConfigureAwait(false);
siteStats.FutureEventAttendeesCount = await CountFutureEventAttendees(log, conn).ConfigureAwait(false);
siteStats.ContactRequestsCount = await CountContactRequests(log, conn).ConfigureAwait(false);
}
await SendSummaryReport(siteStats, instanceName, sendGridApiKey).ConfigureAwait(false);
}
