public async Task <ActionResult> Edit(int id, [Bind("Id,Title,Owner")] Todo todo)
{
await _downstreamWebApi.CallWebApiForUserAsync <Todo, Todo>(
ServiceName,
todo,
downstreamWebApiOptionsOverride : options =>
{
options.HttpMethod = HttpMethod.Patch;
options.RelativePath = $"api/todolist/{todo.Id}";
});
return(RedirectToAction("Index"));
}
public override async Task <HelloReply> SayHello(HelloRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
httpContext.VerifyUserHasAnyAcceptedScope(scopeRequiredByApi);
using var response = await _downstreamWebApi.CallWebApiForUserAsync("DownstreamApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var apiResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
// Do something with apiResult
}
else
{
var error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
return(new HelloReply()
{
Message = "Hello " + request.Name
});
}
/// <summary>
/// Calls the web API with an HttpPost, providing strongly typed input and getting
/// strongly typed output.
/// </summary>
/// <typeparam name="TOutput">Output type.</typeparam>
/// <typeparam name="TInput">Input type.</typeparam>
/// <param name="downstreamWebApi">The downstream web API.</param>
/// <param name="serviceName">Name of the service describing the downstream web API. There can
/// be several configuration named sections mapped to a <see cref="DownstreamWebApiOptions"/>,
/// each for one downstream web API. You can pass-in null, but in that case <paramref name="downstreamWebApiOptionsOverride"/>
/// needs to be set.</param>
/// <param name="relativePath">Path to the API endpoint relative to the base URL specified in the configuration.</param>
/// <param name="inputData">Input data sent to the API.</param>
/// <param name="downstreamWebApiOptionsOverride">Overrides the options proposed in the configuration described
/// by <paramref name="serviceName"/>.</param>
/// <param name="user">[Optional] Claims representing a user. This is useful in platforms like Blazor
/// or Azure Signal R, where the HttpContext is not available. In other platforms, the library
/// will find the user from the HttpContext.</param>
/// <param name="authenticationScheme">Authentication scheme. If null, will use OpenIdConnectDefault.AuthenticationScheme
/// if called from a web app, and JwtBearerDefault.AuthenticationScheme if called from a web API.</param>
/// <returns>A strongly typed response from the web API.</returns>
public static async Task <TOutput?> PostForUserAsync <TOutput, TInput>(
this IDownstreamWebApi downstreamWebApi,
string serviceName,
string relativePath,
TInput inputData,
Action <DownstreamWebApiOptions>?downstreamWebApiOptionsOverride = null,
ClaimsPrincipal?user = null,
string?authenticationScheme = null)
where TOutput : class
{
if (downstreamWebApi is null)
{
throw new ArgumentNullException(nameof(downstreamWebApi));
}
using StringContent? input = ConvertFromInput(inputData);
HttpResponseMessage response = await downstreamWebApi.CallWebApiForUserAsync(
serviceName,
authenticationScheme,
PrepareOptions(relativePath, downstreamWebApiOptionsOverride, HttpMethod.Post),
user,
input).ConfigureAwait(false);
return(await ConvertToOutput <TOutput>(response).ConfigureAwait(false));
}
public async Task <IEnumerable <WeatherForecast> > Get()
{
using var response = await _downstreamWebApi.CallWebApiForUserAsync("DownstreamApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var apiResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
// Do something
}
else
{
var error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray());
}
public async Task <IEnumerable <WeatherForecast> > Get()
{
HttpContext.VerifyUserHasAnyAcceptedScope(scopeRequiredByApi);
var response = await _downstreamWebApi.CallWebApiForUserAsync("CalledApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string apiResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
// Do something
}
else
{
string error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
var rng = new Random();
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray());
}
public async Task <ActionResult> CallAzureFunction()
{
string message = await _downstreamWebApi.CallWebApiForUserAsync <string>(
"AzureFunction");
ViewBag.reply = message;
return(View());
}
public async Task OnGet()
{
//https://docs.microsoft.com/en-us/azure/active-directory/develop/scenario-web-app-call-api-call-api?tabs=aspnetcore
OrdersList = await _integrationWebApi.CallWebApiForUserAsync <Order[]>("OrdersViaOnBehalfOf", options =>
{
options.RelativePath = "OrdersOnBehalfOf";
});
}
public async Task <ActionResult> Get()
{
_logger.LogInformation("Trying to call a downstream Api");
var value = await _downstreamWebApi.CallWebApiForUserAsync(
"WebApi2",
options =>
{
options.HttpMethod = HttpMethod.Get;
options.RelativePath = "api/downstream";
});
return(Ok(value));
}
// GET: TodoList
public async Task <ActionResult> Index()
{
var value = await _downstreamWebApi.CallWebApiForUserAsync <object, IEnumerable <Todo> >(
ServiceName,
null,
options =>
{
options.RelativePath = "api/todolist";
});
return(View(value));
}
public async Task <string> Get()
{
using var response = await _downstreamWebApi.CallWebApiForUserAsync("DownstreamApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
// Do something
}
else
{
var error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
}
public async Task OnGet()
{
using var response = await _downstreamWebApi.CallWebApiForUserAsync("DownstreamApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var apiResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
ViewData["ApiResult"] = apiResult;
}
else
{
var error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
}
/// <summary>
/// Call a web API endpoint with an HttpGet,
/// and return strongly typed data.
/// </summary>
/// <typeparam name="TOutput">Output type.</typeparam>
/// <param name="downstreamWebApi">The downstream web API.</param>
/// <param name="serviceName">Name of the service describing the downstream web API. There can
/// be several configuration named sections mapped to a <see cref="DownstreamWebApiOptions"/>,
/// each for one downstream web API. You can pass-in null, but in that case <paramref name="downstreamWebApiOptionsOverride"/>
/// needs to be set.</param>
/// <param name="downstreamWebApiOptionsOverride">Overrides the options proposed in the configuration described
/// by <paramref name="serviceName"/>.</param>
/// <param name="user">[Optional] Claims representing a user. This is useful in platforms like Blazor
/// or Azure Signal R, where the HttpContext is not available. In other platforms, the library
/// will find the user from the HttpContext.</param>
/// <returns>The value returned by the downstream web API.</returns>
public static async Task <TOutput?> CallWebApiForUserAsync <TOutput>(
this IDownstreamWebApi downstreamWebApi,
string serviceName,
Action <DownstreamWebApiOptions>?downstreamWebApiOptionsOverride = null,
ClaimsPrincipal?user = null)
where TOutput : class
{
if (downstreamWebApi is null)
{
throw new ArgumentNullException(nameof(downstreamWebApi));
}
HttpResponseMessage response = await downstreamWebApi.CallWebApiForUserAsync(
serviceName,
downstreamWebApiOptionsOverride,
user,
null).ConfigureAwait(false);
return(await ConvertToOutput <TOutput>(response).ConfigureAwait(false));
}
public async Task OnGet()
{
var user = await _graphServiceClient.Me.Request().GetAsync();
try
{
using (var photoStream = await _graphServiceClient.Me.Photo.Content.Request().GetAsync())
{
byte[] photoByte = ((MemoryStream)photoStream).ToArray();
ViewData["photo"] = Convert.ToBase64String(photoByte);
}
ViewData["name"] = user.DisplayName;
var graphData = await _downstreamWebApi.CallWebApiForUserAsync("GraphBeta");
}
catch (Exception)
{
ViewData["photo"] = null;
}
}
/// <summary>
/// Call a web API with a strongly typed input, with an HttpGet.
/// </summary>
/// <typeparam name="TInput">Input type.</typeparam>
/// <param name="downstreamWebApi">The downstream web API.</param>
/// <param name="serviceName">Name of the service describing the downstream web API. There can
/// be several configuration named sections mapped to a <see cref="DownstreamWebApiOptions"/>,
/// each for one downstream web API. You can pass-in null, but in that case <paramref name="downstreamWebApiOptionsOverride"/>
/// needs to be set.</param>
/// <param name="inputData">Input data.</param>
/// <param name="downstreamWebApiOptionsOverride">Overrides the options proposed in the configuration described
/// by <paramref name="serviceName"/>.</param>
/// <param name="user">[Optional] Claims representing a user. This is useful in platforms like Blazor
/// or Azure Signal R, where the HttpContext is not available. In other platforms, the library
/// will find the user from the HttpContext.</param>
/// <returns>The value returned by the downstream web API.</returns>
public static async Task GetForUserAsync <TInput>(
this IDownstreamWebApi downstreamWebApi,
string serviceName,
TInput inputData,
Action <DownstreamWebApiOptions>?downstreamWebApiOptionsOverride = null,
ClaimsPrincipal?user = null)
{
if (downstreamWebApi is null)
{
throw new ArgumentNullException(nameof(downstreamWebApi));
}
using StringContent? input = ConvertFromInput(inputData);
await downstreamWebApi.CallWebApiForUserAsync(
serviceName,
downstreamWebApiOptionsOverride,
user,
input).ConfigureAwait(false);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req)
{
_logger.LogInformation("C# HTTP trigger function processed a request.");
var(authenticationStatus, authenticationResponse) =
await req.HttpContext.AuthenticateAzureFunctionAsync();
if (!authenticationStatus)
{
return(authenticationResponse);
}
using var response = await _downstreamWebApi.CallWebApiForUserAsync("DownstreamApi").ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var apiResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
// Do something with apiResult
}
else
{
var error = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpRequestException($"Invalid status code in the HttpResponseMessage: {response.StatusCode}: {error}");
}
string name = req.HttpContext.User.Identity.IsAuthenticated ? req.HttpContext.User.GetDisplayName() : null;
var user = await _graphServiceClient.Me.Request().GetAsync();
string responseMessage = string.IsNullOrEmpty(user.DisplayName)
? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
: $"Hello, Graph user: {user.DisplayName}. Hello, {name} .This HTTP triggered function executed successfully.";
return(new JsonResult(responseMessage));
}
/// <summary>
/// Calls the web API endpoint with an HttpPut, providing strongly typed input data.
/// </summary>
/// <typeparam name="TInput">Input type.</typeparam>
/// <param name="downstreamWebApi">The downstream web API.</param>
/// <param name="serviceName">Name of the service describing the downstream web API. There can
/// be several configuration named sections mapped to a <see cref="DownstreamWebApiOptions"/>,
/// each for one downstream web API. You can pass-in null, but in that case <paramref name="downstreamWebApiOptionsOverride"/>
/// needs to be set.</param>
/// <param name="relativePath">Path to the API endpoint relative to the base URL specified in the configuration.</param>
/// <param name="inputData">Input data sent to the API.</param>
/// <param name="downstreamWebApiOptionsOverride">Overrides the options proposed in the configuration described
/// by <paramref name="serviceName"/>.</param>
/// <param name="user">[Optional] Claims representing a user. This is useful in platforms like Blazor
/// or Azure Signal R, where the HttpContext is not available. In other platforms, the library
/// will find the user from the HttpContext.</param>
/// <param name="authenticationScheme">Authentication scheme. If null, will use OpenIdConnectDefault.AuthenticationScheme
/// if called from a web app, and JwtBearerDefault.AuthenticationScheme if called from a web API.</param>
/// <returns>The value returned by the downstream web API.</returns>
public static async Task PutForUserAsync <TInput>(
this IDownstreamWebApi downstreamWebApi,
string serviceName,
string relativePath,
TInput inputData,
Action <DownstreamWebApiOptions>?downstreamWebApiOptionsOverride = null,
ClaimsPrincipal?user = null,
string?authenticationScheme = null)
{
if (downstreamWebApi is null)
{
throw new ArgumentNullException(nameof(downstreamWebApi));
}
using StringContent? input = ConvertFromInput(inputData);
await downstreamWebApi.CallWebApiForUserAsync(
serviceName,
authenticationScheme,
PrepareOptions(relativePath, downstreamWebApiOptionsOverride, HttpMethod.Put),
user,
input).ConfigureAwait(false);
}
public async Task <HttpResponseMessage> CallDownstreamWebApiAsync()
{
HttpContext.VerifyUserHasAnyAcceptedScope(scopeRequiredByApi);
return(await _downstreamWebApi.CallWebApiForUserAsync(TestConstants.SectionNameCalledApi));
}
public Task <IEnumerable <Order> > List()
{
return(_downstreamWebApi.CallWebApiForUserAsync <IEnumerable <Order> >("BackEndApi", options => options.RelativePath = "Orders"));
}
public async Task <HttpResponseMessage> CallDownstreamWebApiAsync()
{
return(await _downstreamWebApi.CallWebApiForUserAsync(TestConstants.SectionNameCalledApi));
}
public async Task <HttpResponseMessage> CallDownstreamWebApiAsync()
{
return(await _downstreamWebApi.CallWebApiForUserAsync(
TestConstants.SectionNameCalledApi,
authenticationScheme : TestConstants.CustomJwtScheme2));
}
