Goffo.OracleFusion.Api.Core 1.1.0

Goffo.OracleFusion.Api.Core

How to use

Create an implementation for the IFusionApi<TRequest, TResponse>

TRequest is what will hold your request payload for the Oracle Fusion API.

TResponse is what will hold the return response from the Oracle Fusion API

Use the ITokenProvider to create an implementation to get a token

Example

Appsettings.json

{
  "FusionApiEndpoints": {
    "Post": "https://example.com/api/post"
  }
}

    public class ApiExample
    {
        private readonly IServiceCollection _services;

        public ApiExample()
        {
            // Dependency injection setup
            _services = new ServiceCollection();

            // Uses appsettings.json to configure the Fusion API endpoints
            _services.AddFusionApi<FusionApi, FusionRequest, FusionResponse>();

            // Our configure in method
            //_services.AddFusionApi<FusionApi, FusionRequest, FusionResponse>((endpoints) =>
            //{
             //   endpoints.Post = "https://api.example.com/fusion";
            //});

            _services.AddHttpClient<ITokenProvider, TokenProvider>();
        }

        public class FusionApi : IFusionApi<FusionRequest, FusionResponse>
        {
            // Inject HttpClient via constructor injection
            // This is setup in the AddFusionApi extension method
            private readonly HttpClient _client;
            private readonly ITokenProvider _tokenProvider;
            public FusionApi(HttpClient client, ITokenProvider tokenProvider)
            {
                _client = client;
                _tokenProvider = tokenProvider;
            }
            public async Task<FusionResponse> PostAsync(FusionRequest request, CancellationToken cancellationToken = default)
            {
                // Your code to handle the request and return a response...

                // For example you might need to get a token first
                Token token = await _tokenProvider.GetTokenAsync(cancellationToken);

                // use the token to set the Authorization header
                _client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(token.TokenType, token.AccessToken);

                // Now you can make the actual API call
                var response = await _client.PostAsJsonAsync("https://api.example.com/fusion", request, cancellationToken);
                if (response.IsSuccessStatusCode)
                {
                    return await response.Content.ReadFromJsonAsync<FusionResponse>();
                }

                return new FusionResponse(IsSuccess: false);
            }
        }

        public record FusionRequest(string Payload);
        public record FusionResponse(bool IsSuccess);
        public class TokenProvider : ITokenProvider
        {
            private readonly HttpClient _client;
            private Token _cacheToken = new("", "", 0, "");
            public TokenProvider(HttpClient client)
            {
                _client = client;
            }
            public async Task<Token> GetTokenAsync(CancellationToken cancellationToken = default)
            {
                // Your code to get a token....
                // You probably want to cache the token and handle expiration

                System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler handler = new();
                System.IdentityModel.Tokens.Jwt.JwtSecurityToken securityToken = handler.ReadJwtToken(_cachedToken.AccessToken);
                object? tokenExp = null;
                DateTime expDateTime = DateTime.Now.AddDays(1);

                if (securityToken.Payload.TryGetValue("exp", out tokenExp))
                {
                    expDateTime = DateTimeOffset.FromUnixTimeSeconds(Convert.ToInt64(tokenExp)).LocalDateTime;
                    bool isValid = expDateTime < DateTime.Now.AddSeconds(-10);

                    if(isValid)
                    {
                        // Token is still valid, return cached token
                        return _cacheToken;
                    }
                }

                // You may want to make an API call
                Dictionary<string, string?> formUrlContent = new Dictionary<string, string?>
                {
                    { "grant_type", "client_credentials" },
                    { "client_id", "client-id" },
                    { "client_secret", "client-secret" },
                    { "scope", "your-scope" }
                };

                var response = await _client.PostAsJsonAsync("https://api.example.com/fusion", new FormUrlEncodedContent(formUrlContent), cancellationToken);

                if (response.IsSuccessStatusCode)
                {
                    Token token = await response.Content.ReadFromJsonAsync<Token>();
                    _cacheToken = token;
                    return token;
                }

                throw new TokenException(response.StatusCode, response.ReasonPhrase, await response.Content.ReadAsStringAsync());
            }
        }
    }