Infrastructure/RemoteAccessTokenProvider.cs - master - rezvich/SoapBatchProcessor

Infrastructure/RemoteAccessTokenProvider.cs
89 строк3 KB
rezvich
Подправил токен
04 авг 2026, 12:20
04 авг 2026, 12:20632636d
using System.Net.Http.Json;
using System.Text.Json.Serialization;

namespace SoapBatchProcessor.Infrastructure
{
    public sealed class RemoteAccessTokenProvider : IAccessTokenProvider
    {
        private readonly HttpClient _http;
        private readonly string? _apiKey;

        private sealed class TokenDto
        {
            [JsonPropertyName("access_token")]
            public string AccessToken { get; set; } = string.Empty;

            [JsonPropertyName("expires_at_utc")]
            public DateTimeOffset ExpiresAtUtc { get; set; }

            [JsonPropertyName("refresh_after_utc")]
            public DateTimeOffset RefreshAfterUtc { get; set; }

            [JsonPropertyName("token_version")]
            public long TokenVersion { get; set; }
        }

        private sealed class RejectedTokenDto
        {
            [JsonPropertyName("rejected_token_version")]
            public long RejectedTokenVersion { get; init; }
        }

        public RemoteAccessTokenProvider(HttpClient http, string? apiKey = null)
        {
            _http = http ?? throw new ArgumentNullException(nameof(http));
            _apiKey = apiKey;
        }

        public async Task<AccessTokenLease> GetAccessTokenLeaseAsync(CancellationToken ct = default)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, "/iam/access-token");

            AddApiKey(req);

            return await SendAsync(req, ct);
        }

        public async Task<AccessTokenLease> RefreshAfterRejectionAsync(
            long rejectedTokenVersion,
            CancellationToken ct = default)
        {
            using var req = new HttpRequestMessage(HttpMethod.Post, "/iam/access-token/refresh")
            {
                Content = JsonContent.Create(new RejectedTokenDto
                {
                    RejectedTokenVersion = rejectedTokenVersion
                })
            };
            AddApiKey(req);

            return await SendAsync(req, ct);
        }

        private void AddApiKey(HttpRequestMessage req)
        {
            if (!string.IsNullOrWhiteSpace(_apiKey))
                req.Headers.TryAddWithoutValidation("X-Api-Key", _apiKey);
        }

        private async Task<AccessTokenLease> SendAsync(
            HttpRequestMessage req,
            CancellationToken ct)
        {
            using var resp = await _http.SendAsync(req, ct);
            resp.EnsureSuccessStatusCode();

            var dto = await resp.Content.ReadFromJsonAsync<TokenDto>(cancellationToken: ct);
            if (dto == null || string.IsNullOrWhiteSpace(dto.AccessToken))
                throw new InvalidOperationException("TokenService вернул пустой access_token");

            return new AccessTokenLease
            {
                AccessToken = dto.AccessToken,
                ExpiresAtUtc = dto.ExpiresAtUtc,
                RefreshAfterUtc = dto.RefreshAfterUtc,
                TokenVersion = dto.TokenVersion
            };
        }
    }
}