adding endpoint for getting the current playback state

GrpcShared/DTO/TokenMessage.cs

 
 namespace GrpcShared.DTO
 {
-    [ProtoContract]
+    [ProtoContract(SkipConstructor = true)]
     public class TokenMessage
     {
+        
+        public TokenMessage(string? token)
+        {
+            Token = token;
+        }
+
         [ProtoMember(1)]
         public string? Token { get; set; }
     }

GrpcShared/Interfaces/IStatsService.cs

-using GrpcShared.DTO.Track;
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
 using ProtoBuf.Grpc.Configuration;
 using System;
 using System.Collections.Generic;
     [Service]
     public interface IStatsService
     {
-        Task<TrackResponse> GetCurrentlyPlayingTrack(string token);
+        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

NemAnCore/Pages/Home.razor

 @page "/home"
-@attribute [Authorize]
+@using GrpcShared.DTO
+@using GrpcShared.DTO.Track
+@using NemAnBlazor.Services.Interfaces
+@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
+@inject IStatsClientService spotifyService
+
 <h3>Home</h3>
 
 <p>login radi</p>
 <AuthorizeView>
     <Authorized> 
         <p>autorizovan si</p>
+        
     </Authorized>
     <NotAuthorized>
         <LoginRedirect/>
     </NotAuthorized>
 </AuthorizeView>
 @code {
+    protected override async Task OnInitializedAsync()
+    {
+        //string tokenS = await sessionStorage.GetItemAsync<string>("token");
+        //TokenMessage token = new TokenMessage(tokenS);
 
+        //TrackResponse response = await spotifyService.GetCurrentlyPlayingTrack(token);
+    }
 }

NemAnCore/Program.cs

 
 builder.Services.AddScoped<ITrackClientService, TrackClientService>();
 builder.Services.AddScoped<IAuthClientService, AuthClientService>();
+builder.Services.AddScoped<IStatsClientService, StatsClientService>();
 builder.Services.AddBlazoredSessionStorage();
 builder.Services.AddScoped<AuthenticationStateProvider, AuthClientService>();
 builder.Services.AddAuthorizationCore();

NemAnCore/Services/AuthClientService.cs

             //token = "BQBMgFm6jnFNWWeZEMGIRP_f-ENPid7Kw8JubAyuWAe4JK0S1DPFGlaAdZ_Fey6ePkCnz8-cqC0oyRmrciWUy5ISUTQKDe8PTQn4iBRMYCgM0n4GnS1xAErHJcm4Vpu2TAngk-4vQUOfTQRcedNTfCaHKP4uFJgTlTI7JHGrtB-_EZLnFcZ2OQe31oFQIJ1wM3ZtvwnN";
             if (token == null) return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
             
-            var userInfo = await _serviceClient.GetUserInfo(new TokenMessage { Token = token });
+            var userInfo = await _serviceClient.GetUserInfo(new TokenMessage ( token ));
 
             List<Claim> claims = new();
 

NemAnCore/Services/Interfaces/IStatsClientService.cs

-namespace NemAnBlazor.Services.Interfaces
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
+
+namespace NemAnBlazor.Services.Interfaces
 {
     public interface IStatsClientService
     {
+        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

NemAnCore/Services/StatsClientService.cs

-using NemAnBlazor.Services.Interfaces;
+using Grpc.Net.Client;
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
+using GrpcShared.Interfaces;
+using NemAnBlazor.Services.Interfaces;
+using ProtoBuf.Grpc.Client;
 
 namespace NemAnBlazor.Services
 {
-    public class StatsClientService :IStatsClientService
+    public class StatsClientService : IStatsClientService
     {
+        private IStatsService _serviceClient;
+        public StatsClientService(GrpcChannel channel)
+        {
+            _serviceClient = channel.CreateGrpcService<IStatsService>();
+        }
+        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
+        {
+            return await _serviceClient.GetCurrentlyPlayingTrack(token);
+        }
     }
 }

gRPCServer/Services/StatsService.cs

 
+using GrpcShared.DTO;
 using GrpcShared.DTO.Track;
 using GrpcShared.Interfaces;
+using Microsoft.Net.Http.Headers;
+using Newtonsoft.Json;
 
 namespace SpotifyService.Services
 {
         public StatsService(IHttpClientFactory httpClientFactory)
         {
             _httpClientFactory = httpClientFactory;
-        }
-        public Task<TrackResponse> GetCurrentlyPlayingTrack(string token)
+        }     
+
+        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
         {
-            return null;
+            var client = _httpClientFactory.CreateClient();
+            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + token);
+
+            var searchResult = await client.GetAsync($"player/currently-playing");
+
+            var responses = JsonConvert.DeserializeObject<TrackResponse>(await searchResult.Content.ReadAsStringAsync())!;
+
+           return responses;
+
         }
     }
 }