NemAn/IdentityProvider/Services/AuthService.cs

//using IdentityProvider.Protos.AuthService;
using Grpc.Net.Client;
using GrpcShared;
using GrpcShared.DTO;
using GrpcShared.DTO.Auth;
using GrpcShared.DTO.User;
using GrpcShared.Interfaces;
using Microsoft.Extensions.Options;
using Microsoft.Net.Http.Headers;
using Newtonsoft.Json;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

namespace IdentityProvider.Services
{
    public class AuthService : IAuthService
    {
        private readonly ILogger<AuthService> _logger;
        private readonly CodeRequest _params;
        private readonly IHttpClientFactory _httpClientFactory;
        public AuthService(ILogger<AuthService> logger, IOptions<CodeRequest> options, IHttpClientFactory httpClientFactory)
        {
            _logger = logger;
            _params = options.Value;
            _httpClientFactory = httpClientFactory;
        }


        public async Task<TokenResponse> GetAccessToken(TokenRequest tokenRequest)
        {
            var http = _httpClientFactory.CreateClient();

            string url = "https://accounts.spotify.com/api/token";
            http.BaseAddress = new Uri(url);

            //get client id and secret, and redirect uri from appsettings, convert to base64 and set as header
            var secrets = await GetAuthParams();
            byte[] contentType = Encoding.UTF8.GetBytes($"{secrets.ClientId}:{secrets.ClientSecret}");
            tokenRequest.redirect_uri = secrets.RedirectURI;

            //AUTHORIZATION HEADER
            http.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Basic " + Convert.ToBase64String(contentType));

            ////ACCEPT HEADER
            //http.DefaultRequestHeaders.Accept.Add(
            //        new MediaTypeWithQualityHeaderValue("application/json"));

            //BODY PARAMS
            var requestBody = new Dictionary<string, string>();
            requestBody["grant_type"] = tokenRequest.grant_type;
            requestBody["code"] = tokenRequest.code!;
            requestBody["redirect_uri"] = tokenRequest.redirect_uri!;

            //REQUEST
            var response = await http.PostAsync(url, new FormUrlEncodedContent(requestBody));

            var contents = JsonConvert.DeserializeObject<TokenResponse>(await response.Content.ReadAsStringAsync());
            if (contents != null)
                return new TokenResponse
                {
                    access_token = contents!.access_token,
                    refresh_token = contents!.refresh_token,
                    expires_in = contents!.expires_in
                };
            else return null;
        }

        public async Task<CodeRequest> GetAuthParams()
        {
            var authParams = new CodeRequest
            {
                ClientId = _params.ClientId,
                RedirectURI = _params.RedirectURI,
                Scope = _params.Scope,
                ClientSecret = _params.ClientSecret
            };
            return await Task.FromResult(authParams);
        }

        public async Task<UserInfoResponse> GetUserInfo(TokenMessage token)
        {
            var http = _httpClientFactory.CreateClient();
            http.BaseAddress = new Uri(SpotifyService.GLOBALS.SPOTIFYURL);
            
            //AUTHORIZATION HEADER
            http.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + token.Token);

            var response = await http.GetAsync(http.BaseAddress + "me");

            var user = JsonConvert.DeserializeObject<UserInfoResponse>(await response.Content.ReadAsStringAsync());

            return await Task.FromResult(user!);
        }
    }
}