public static async Task <IActionResult> Run(
[HttpTrigger(
AuthorizationLevel.Function,
nameof(HttpMethods.Post),
Route = null)] Player player,
[Blob(
BlobConfig.Container,
FileAccess.Write,
Connection = "StorageAccount")] CloudBlobContainer cloudBlobContainer)
{
IActionResult result;
if (player == null)
{
result = new BadRequestObjectResult("No player data in request.");
}
else
{
var blob = cloudBlobContainer.GetBlockBlobReference($"out/cloudblob-{player.NickName}.json");
var playerBlob = JsonConvert.SerializeObject(player);
await blob.UploadTextAsync(playerBlob);
result = new AcceptedResult();
}
return(result);
}
public async Task RequestContainingExistingLocationReturnsAccepted()
{
var locationDetailsRequestModel = CreateValidLocationDetailsRequestModel();
var formByteArray = ToByteArray(locationDetailsRequestModel);
_httpRequest.Setup(x => x.Body).Returns(new MemoryStream(formByteArray));
var addResult = new WriteRequestResult {
Status = WriteRequestStatus.Duplicate, ItemId = Guid.NewGuid()
};
_locationDetailsService.Setup(x => x.Add(It.IsAny <LocationDetailsDto>())).Returns(Task.FromResult(addResult));
_mapper.Setup(x => x.Map <LocationDetailsDto>(It.IsAny <LocationDetailsRequestModel>()))
.Returns((LocationDetailsRequestModel source) =>
{
return(new LocationDetailsDto()
{
GameOverviewList = new Dictionary <string, int>()
});
});
Environment.SetEnvironmentVariable("ReadBaseUrl", "testConfigValue");
var expected = new AcceptedResult("", new { });
var actual = await _sut.Run(_httpRequest.Object, _log.Object);
Assert.Equal(expected.GetType(), actual.GetType());
Environment.SetEnvironmentVariable("ReadBaseUrl", null);
}
public static IActionResult Run(
[HttpTrigger(
AuthorizationLevel.Function,
"post",
Route = null)] Player player,
[Blob(
"players/out/string-{rand-guid}.json",
FileAccess.Write)] out string playerBlob)
{
playerBlob = default;
IActionResult result;
if (player == null)
{
result = new BadRequestObjectResult("No player data in request.");
}
else
{
playerBlob = JsonConvert.SerializeObject(player, Formatting.Indented);
result = new AcceptedResult();
}
return(result);
}
public static async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log,
[ServiceBus("newreview", EntityType.Topic, Connection = "topicConnectionString")] IAsyncCollector <string> outputs
)
{
string rawRequestBody = await new StreamReader(req.Body).ReadToEndAsync();
string CorrelationId = Guid.NewGuid().ToString();
string statusCheckEndpoint = $"{Environment.GetEnvironmentVariable("statusCheckURL")}/{CorrelationId}";
string reviewerMessageEnvelope = MessageHelper.DecorateJsonBody(rawRequestBody,
new Dictionary <string, JToken>()
{
{ "RequestCorrelationId", CorrelationId },
{ "RequestCreatedAt", DateTime.Now },
{ "RequestStatus", statusCheckEndpoint }
}
);
await outputs.AddAsync(reviewerMessageEnvelope);
AcceptedResult acceptedResultObject = new AcceptedResult();
acceptedResultObject.Location = statusCheckEndpoint;
return((ActionResult)acceptedResultObject);
}
public static async Task <IActionResult> Run(
[HttpTrigger(
AuthorizationLevel.Function,
nameof(HttpMethods.Post),
Route = null)] Player player,
IBinder binder)
{
var serializedPlayer = JsonConvert.SerializeObject(player);
var cloudQueueMessage = new CloudQueueMessage(serializedPlayer); // Not WindowsAzure.Storage.Queue!
IActionResult result = null;
if (string.IsNullOrEmpty(player.Id))
{
var queueAttribute = new QueueAttribute(QueueConfig.NewPlayerErrorItems);
var cloudQueue = await binder.BindAsync <CloudQueue>(queueAttribute);
await cloudQueue.AddMessageAsync(cloudQueueMessage);
result = new BadRequestObjectResult("No player data in request.");
}
else
{
var queueAttribute = new QueueAttribute(QueueConfig.NewPlayerItems);
var cloudQueue = await binder.BindAsync <CloudQueue>(queueAttribute);
await cloudQueue.AddMessageAsync(cloudQueueMessage);
result = new AcceptedResult();
}
return(result);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, methods: "post", Route = "submit")]
HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient orchestrationClient,
ILogger logger)
{
logger.LogInformation("Submission received via Http");
string requestBody = new StreamReader(req.Body).ReadToEnd();
var submission = JsonConvert.DeserializeObject <Presentation>(requestBody, new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
var instanceId = await orchestrationClient.StartNewAsync("ProcessSubmission", submission);
logger.LogInformation("Submission process started", instanceId);
string checkStatusLocacion = string.Format("{0}://{1}/api/status/{2}", req.Scheme, req.Host, instanceId); // To inform the client where to check the status
string message = $"Your submission has been received. To get the status, go to: {checkStatusLocacion}";
// Create an Http Response with Status Accepted (202) to let the client know that the request has been accepted but not yet processed.
ActionResult response = new AcceptedResult(checkStatusLocacion, message); // The GET status location is returned as an http header
req.HttpContext.Response.Headers.Add("retry-after", "20"); // To inform the client how long to wait in seconds before checking the status
return(response);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, methods: "get", Route = "status/{instanceId}")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient orchestrationClient,
string instanceId,
ILogger logger)
{
var sourceGetStatusKey = Environment.GetEnvironmentVariable("GetStatusKey");
// Get the built-in status of the orchestration instance. This status is managed by the Durable Functions Extension.
var status = await orchestrationClient.GetStatusAsync(instanceId);
if (status != null)
{
if (status.RuntimeStatus == OrchestrationRuntimeStatus.Running || status.RuntimeStatus == OrchestrationRuntimeStatus.Pending)
{
//The URL (location header) is prepared so the client know where to get the status later.
string checkStatusLocacion = string.Format("{0}://{1}/api/status/{2}?code={3}", req.Scheme, req.Host, instanceId, sourceGetStatusKey);
string message = $"The zip file is being processed. The current status is ''. To check the status later, go to: GET {checkStatusLocacion}"; // To inform the client where to check the status
// Create an Http Response with Status Accepted (202) to let the client know that the original request hasn't yet been fully processed.
ActionResult response = new AcceptedResult(checkStatusLocacion, message); // The GET status location is returned as an http header
//req.HttpContext.Response.Headers.Add("x-functions-key", sourceGetStatusKey); // add getstatus key as header
req.HttpContext.Response.Headers.Add("retry-after", "3"); // To inform the client how long to wait before checking the status.
return(response);
}
else if (status.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
// Once the orchestration has been completed, an Http Response with Status OK (200) is created to inform the client that the original request has been fully processed.
return(new OkObjectResult($"Congratulations, your presentation with id '{instanceId}' has been Completed!"));
}
}
// If status is null, then instance has not been found. Create and return an Http Response with status NotFound (404).
return(new NotFoundObjectResult($"Whoops! Something went wrong. Please check if your submission Id is correct. Submission '{instanceId}' not found."));
}
private static async Task <IActionResult> UpsertPerson(
string path,
PersonModel model,
Person existing,
string jurisdiction,
IAsyncCollector <Person> peopleCollection,
ILogger log,
CancellationToken cancellationToken)
{
Person record;
IActionResult response;
if (existing == null)
{
log.LogInformation("Creating new person record.");
record = model.ToData(jurisdiction);
await peopleCollection.AddAsync(record, cancellationToken);
response = new CreatedResult(path, new CreatePersonResponseModel
{
Id = record.Id
});
}
else
{
log.LogInformation("Updating existing person record.");
record = model.Map(existing);
await peopleCollection.AddAsync(record, cancellationToken);
response = new AcceptedResult();
}
return(response);
}
public static async Task <IActionResult> Run(
[HttpTrigger(
AuthorizationLevel.Function,
nameof(HttpMethods.Post),
Route = null)] Player player,
[Blob(
"players/out/stream-{rand-guid}.json",
FileAccess.Write)] Stream playerStream)
{
IActionResult result;
if (player == null)
{
result = new BadRequestObjectResult("No player data in request.");
}
else
{
using var writer = new StreamWriter(playerStream);
var jsonData = JsonConvert.SerializeObject(player);
await writer.WriteLineAsync(jsonData);
result = new AcceptedResult();
}
return(result);
}
public void Put_Success()
{
// Arrange
CashDeskItem item = new CashDeskItem()
{
Id = "5c012842f8e2708cf041e247",
Name = "Caisse_01"
};
_cashDeskServicesMock.Setup(x => x.GetCashDesk(item.Id)).Returns(Task.FromResult(item));
_cashDeskServicesMock.Setup(x => x.UpdateCashDesk(item.Id, item))
.ReturnsAsync(true)
.Verifiable();
_cashDeskFlowValidMock
.Setup(x => x.IsValidOperation(BaseValidatorType.Update, It.IsAny <CashDeskItem>(), It.IsAny <CashDeskItem>()))
.Returns(true)
.Verifiable();
// Act
CashDeskController controller = new CashDeskController(_cashDeskServicesMock.Object, _cashDeskFlowValidMock.Object);
ActionResult actionResult = controller.Put(item);
// Assert.
Assert.IsType <AcceptedResult>(actionResult);
AcceptedResult actionResultType = actionResult as AcceptedResult;
Assert.Equal(actionResultType.StatusCode, (int)System.Net.HttpStatusCode.Accepted);
_cashDeskServicesMock.Verify();
_cashDeskFlowValidMock.Verify();
}
public static async Task <IActionResult> Run(
[HttpTrigger(
AuthorizationLevel.Function,
nameof(HttpMethods.Post),
Route = null)] Player[] players,
[Queue(QueueConfig.NewPlayerItems)] IAsyncCollector <Player> collector)
{
IActionResult result = null;
if (players.Any())
{
foreach (var player in players)
{
await collector.AddAsync(player);
}
result = new AcceptedResult();
}
else
{
result = new BadRequestObjectResult("No player data in request.");
}
return(result);
}
public static async Task <IActionResult> Run(
[HttpTrigger(
AuthorizationLevel.Function,
"post",
Route = null)] Player player,
IBinder binder)
{
//playerBlob = default;
IActionResult result;
if (player == null)
{
result = new BadRequestObjectResult("No player data in request.");
}
else
{
// playerBlob = JsonConvert.SerializeObject(player, Formatting.Indented);
var blobAttribute1 = new BlobAttribute($"players/out/dynamic-{player.Id}");
var blobAttribute = new BlobAttribute($"players/out/dynamic-{player.Id}.json");
using (var output = await binder.BindAsync <TextWriter>(blobAttribute))
{
await output.WriteAsync(JsonConvert.SerializeObject(player));
}
result = new AcceptedResult();
}
return(result);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, methods: "get", Route = "result/{instanceId}")]
HttpRequest req,
[DurableClient] IDurableOrchestrationClient client,
string instanceId,
ILogger log)
{
var status = await client.GetStatusAsync(instanceId);
if (status.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
return(new OkObjectResult(status.Output));
}
else if (status.RuntimeStatus == OrchestrationRuntimeStatus.Running)
{
string checkStatusLocation = $"{req.Scheme}://{req.Host}/api/result/{instanceId}";
string message = $"Your submission is being processed. The current status is {client.GetStatusAsync().Status}. To check the status later, go to: GET {checkStatusLocation}";
ActionResult response = new AcceptedResult(checkStatusLocation, message); // The GET status location is returned as an http header
return(response);
}
else
{
return(new BadRequestObjectResult(status.RuntimeStatus.ToString()));
}
}
public void Constructor_InitializesStatusCodeAndValue(object value)
{
// Arrange & Act
var result = new AcceptedResult("testlocation", value);
// Assert
Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);
Assert.Same(value, result.Value);
}
public void ValueAs_Null_ShouldFail()
{
ActionResult result = new AcceptedResult(TestUri, null);
var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
"AcceptedResult.Value", typeof(object));
Action a = () => result.Should().BeAcceptedResult().ValueAs <object>();
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public async Task RetryAfterIsNotSetWhenNoTimeSpanIsProvided()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse());
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Content.Headers.Should().NotContain("Retry-After", "because the response should not specify the Retry-After.");
}
public async Task RetryAfterIsNotSetForTimeSpanZero()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse(), TimeSpan.Zero);
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Headers.RetryAfter.Should().BeNull("because the response should not specify the Retry-After.");
}
public async void HttpStatusCodeIsCorrect()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse());
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.StatusCode.Should().Be(HttpStatusCode.Accepted, "because the result should set the provided status code");
}
public async Task ExecuteResultAsync_SetsStatusCodeAndLocationHeader()
{
// Arrange
var expectedUrl = "testAction";
var httpContext = GetHttpContext();
// Act
var result = new AcceptedResult(expectedUrl, value: "some-value");
await result.ExecuteAsync(httpContext);
// Assert
Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);
Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);
}
public async Task <IActionResult> Post([FromBody] CreateCustomerModel model)
{
var customerId = Guid.NewGuid().ToString();
await bus.EnqueueAsync(new CreateCustomerFromApiCommand()
{
DomainObjectId = customerId, //Mandatory Id
Name = model.Name
});
var acceptedResult = new AcceptedResult();
acceptedResult.Location = new Uri($"/api/customers/{customerId}", UriKind.Relative).ToString();
return(acceptedResult);
}
public async Task RetryAfterIsSetOnResponse()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var retrySeconds = TimeSpan.FromSeconds(30);
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse(), retrySeconds);
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Headers.RetryAfter.Should().NotBeNull("Retry-After", "because the response should specify the Retry-After.");
response.Headers.RetryAfter.Delta.Should().Be(retrySeconds, "because the duration should match the provided TimeSpan");
}
public void Points_Delete_StatusCode_202(int status)
{
PointsController controller = new PointsController(_pointRepository);
Point point = new Point()
{
Name = "K", PointId = 10
};
IActionResult result = controller.DeletePoint(point.PointId);
AcceptedResult actionResult = result.Should().BeOfType <AcceptedResult>().Subject;
actionResult.StatusCode.Should().Be(status, $"StatusCode should be {status}");
}
public async Task ExecuteResultAsync_SetsStatusCodeAndLocationHeader()
{
// Arrange
var location = "/test/";
var formatter = CreateMockFormatter();
var httpContext = GetHttpContext(formatter);
var actionContext = GetActionContext(httpContext);
// Act
var result = new AcceptedResult(location, "testInput");
await result.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);
Assert.Equal(location, httpContext.Response.Headers["Location"]);
}
public static async Task <IActionResult> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
[DurableClient] IDurableOrchestrationClient starter, ILogger log)
{
string instanceId = await starter.StartNewAsync("seasonelpromotion", null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
string checkStatusLocacion = string.Format("{0}://{1}/api/status/{2}", req.Scheme, req.Host, instanceId);
string message = $"Status update of the promotional items : {checkStatusLocacion}";
ActionResult response = new AcceptedResult(checkStatusLocacion, message);
req.HttpContext.Response.Headers.Add("retry-after", "20");
return(response);
}
public async Task ExecuteResultAsync_FormatsData()
{
// Arrange
var httpContext = GetHttpContext();
var stream = new MemoryStream();
httpContext.Response.Body = stream;
// Act
var result = new AcceptedResult("my-location", value: "Hello world");
await result.ExecuteAsync(httpContext);
// Assert
var response = Encoding.UTF8.GetString(stream.ToArray());
Assert.Equal("\"Hello world\"", response);
}
public async Task <IActionResult> Post([FromBody] CreateCustomerModel model)
{
var customerId = Guid.NewGuid().ToString();
//The bus will call the customer domain object
await bus.EnqueueAsync(new CreateCustomerFromApiCommand()
{
DomainObjectId = customerId, //Mandatory Id
Name = model.Name
});
var acceptedResult = new AcceptedResult
{
//Give The Client a hint where to get the details( see below).
Location = new Uri($"/api/customers/{customerId}", UriKind.Relative).ToString()
};
return(acceptedResult);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "submit")] HttpRequest req,
[DurableClient] IDurableOrchestrationClient starter,
ILogger log)
{
string payload = req.Body.ToString();
string instanceId = await starter.StartNewAsync("RunOrchestrator", null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
string checkStatusLocation = $"{req.Scheme}://{req.Host}/api/result/{instanceId}";
string message = $"Your submission is being processed. The current status is {starter.GetStatusAsync().Status}. To check the status later, go to: GET {checkStatusLocation}";
ActionResult response = new AcceptedResult(checkStatusLocation, message); // The GET status location is returned as an http header
req.HttpContext.Response.Headers.Add("retry-after", "20"); // To inform the client how long to wait before checking the status.
return(response);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, methods: "get", Route = "status/{instanceId}")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient orchestrationClient,
string instanceId,
ILogger logger)
{
// Get the built-in status of the orchestration instance. This status is managed by the Durable Functions Extension.
var status = await orchestrationClient.GetStatusAsync(instanceId);
if (status != null)
{
// Get the custom status of the orchestration intance. This status is set by our code.
// This can be any serialisable object. In this case, just a string.
string customStatus = (string)status.CustomStatus;
if (status.RuntimeStatus == OrchestrationRuntimeStatus.Running || status.RuntimeStatus == OrchestrationRuntimeStatus.Pending)
{
//The URL (location header) is prepared so the client know where to get the status later.
string checkStatusLocacion = string.Format("{0}://{1}/api/status/{2}", req.Scheme, req.Host, instanceId);
string message = $"Your submission is being processed. The current status is {customStatus}. To check the status later, go to: GET {checkStatusLocacion}"; // To inform the client where to check the status
// Create an Http Response with Status Accepted (202) to let the client know that the original request hasn't yet been fully processed.
ActionResult response = new AcceptedResult(checkStatusLocacion, message); // The GET status location is returned as an http header
req.HttpContext.Response.Headers.Add("retry-after", "20"); // To inform the client how long to wait before checking the status.
return(response);
}
else if (status.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
// Once the orchestration has been completed, an Http Response with Status OK (200) is created to inform the client that the original request has been fully processed.
if (customStatus == "Approved")
{
return(new OkObjectResult($"Congratulations, your presentation with id '{instanceId}' has been accepted!"));
}
else
{
return(new OkObjectResult($"We are sorry! Unfortunately your presentation with id '{instanceId}' has not been accepted."));
}
}
}
// If status is null, then instance has not been found. Create and return an Http Response with status NotFound (404).
return(new NotFoundObjectResult($"Whoops! Something went wrong. Please check if your submission Id is correct. Submission '{instanceId}' not found."));
}
public async Task ExecuteResultAsync_SetsObjectValueOfFormatter(object value)
{
// Arrange
var location = "/test/";
var formatter = CreateMockFormatter();
var httpContext = GetHttpContext(formatter);
object actual = null;
formatter.Setup(f => f.WriteAsync(It.IsAny <OutputFormatterWriteContext>()))
.Callback((OutputFormatterWriteContext context) => actual = context.Object)
.Returns(Task.FromResult(0));
var actionContext = GetActionContext(httpContext);
// Act
var result = new AcceptedResult(location, value);
await result.ExecuteResultAsync(actionContext);
// Assert
Assert.Same(value, actual);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "actions/run")] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var body = default(string);
var payload = default(EventRequest);
using (var reader = new StreamReader(req.Body))
{
body = await reader.ReadToEndAsync();
payload = JsonConvert.DeserializeObject <EventRequest>(body);
}
req.HttpContext.Response.Headers.Add("CARD-ACTION-STATUS", $"Deployment process for {payload.ClientPayload.Artifact.Name} has been resumed.");
using (var content = new StringContent(body))
{
var authKey = this._settings.GitHub.AuthKey;
var endpoint = string.Format(this._settings.GitHub.Endpoints.Dispatches.TrimStart('/'), payload.ClientPayload.Repository.Owner, payload.ClientPayload.Repository.Name);
var requestUri = new Uri($"{this._settings.GitHub.BaseUri.TrimEnd('/')}/{endpoint}");
var accept = this._settings.GitHub.Headers.Accept;
var userAgent = this._settings.GitHub.Headers.UserAgent;
this._client.DefaultRequestHeaders.Clear();
this._client.DefaultRequestHeaders.Add("Authorization", authKey);
this._client.DefaultRequestHeaders.Add("Accept", accept);
this._client.DefaultRequestHeaders.Add("User-Agent", userAgent);
using (var response = await this._client.PostAsync(requestUri, content).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
}
}
var result = new AcceptedResult(new Uri($"https://github.com/{payload.ClientPayload.Repository.Owner}/{payload.ClientPayload.Repository.Name}/actions"), body);
return(result);
}
