get track by id works

GrpcShared/DTO/Track/TrackResponse.cs → GrpcShared/DTO/Track/CurrentTrackResponse.cs

 namespace GrpcShared.DTO.Track
 {
     [ProtoContract]
-    public class TrackResponse
+    public class CurrentTrackResponse
     {
         [ProtoMember(1)]
         public string? timestamp{ get; set; }

GrpcShared/DTO/TrackByID/TrackRequest.cs

+using Newtonsoft.Json;
+using ProtoBuf;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GrpcShared.DTO.TrackByID
+{
+    [ProtoContract]
+    public class TrackRequest
+    {
+        [ProtoMember(1)]
+        [JsonProperty("id")]
+        public string? TrackID { get; set; }
+        [ProtoMember(2)]
+        [JsonProperty("token")]
+        public string? Token { get; set; }
+    }
+}

GrpcShared/DTO/TrackByID/TrackResponse.cs

+using GrpcShared.DTO.Track;
+using Newtonsoft.Json;
+using ProtoBuf;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GrpcShared.DTO.TrackByID
+{
+    [ProtoContract]
+    public class TrackResponse
+    {
+        [ProtoMember(1)]
+        [JsonProperty("album")]
+        public Album Album { get; set; }
+
+        [ProtoMember(2)]
+        [JsonProperty("artists")]
+        public Artist[] Artists { get; set; }
+
+        [ProtoMember(3)]
+        [JsonProperty("duration_ms")]
+        public long DurationMs { get; set; }
+
+        [ProtoMember(4)]
+        [JsonProperty("href")]
+        public Uri Href { get; set; }
+
+        [ProtoMember(5)]
+        [JsonProperty("id")]
+        public string Id { get; set; }
+
+        [ProtoMember(6)]
+        [JsonProperty("name")]
+        public string Name { get; set; }
+    }
+}

GrpcShared/Interfaces/IStatsService.cs

     [Service]
     public interface IStatsService
     {
-        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
+        Task<CurrentTrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

GrpcShared/Interfaces/ITrackService.cs

 using GrpcShared.DTO.Track.MultipleTrack;
 using GrpcShared.DTO.Track.SaveTracks;
 using GrpcShared.DTO.Track.SingleTrack;
+using GrpcShared.DTO.TrackByID;
 using ProtoBuf.Grpc.Configuration;
 using System;
 using System.Collections.Generic;
         Task<SingleTrackResponse> ListSingleTrackAsync(SingleTrackRequest request);
         Task<MultipleTrackResponse> ListMultipleTrackAsync(MultipleTrackRequest request);
         Task SaveTracks(SaveTracksRequest request);
+        Task<TrackResponse> GetById(TrackRequest request);
     }
 }

NemAnCore/Pages/Home.razor

 @using NemAnBlazor.Services.Interfaces
 @inject Blazored.SessionStorage.ISessionStorageService sessionStorage
 @inject IStatsClientService spotifyService
+@inject ITrackClientService trackService
 
 <h3>Home</h3>
 
         string tokenS = await sessionStorage.GetItemAsync<string>("token");
         TokenMessage token = new TokenMessage(tokenS);
 
-        TrackResponse response = await spotifyService.GetCurrentlyPlayingTrack(token);
+       // CurrentTrackResponse response = await spotifyService.GetCurrentlyPlayingTrack(token);
+
+        //napravi komponentu koja ce da prikazuje sta trenutno slusas i passuj joj parametre
+
+        //4fy1A2WBTPX55mUI16TQXa
+        var trackById = await trackService.GetById(new GrpcShared.DTO.TrackByID.TrackRequest { TrackID = "4fy1A2WBTPX55mUI16TQXa", Token = tokenS });
     }
 }

NemAnCore/Services/Interfaces/IStatsClientService.cs

 {
     public interface IStatsClientService
     {
-        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
+        Task<CurrentTrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

NemAnCore/Services/Interfaces/ITrackClientService.cs

 using GrpcShared.DTO.Track.MultipleTrack;
 using GrpcShared.DTO.Track.SaveTracks;
 using GrpcShared.DTO.Track.SingleTrack;
+using GrpcShared.DTO.TrackByID;
 
 namespace NemAnBlazor.Services.Interfaces
 {
         Task<SingleTrackResponse> GetListSingleTrackAsync(SingleTrackRequest request);
         Task<MultipleTrackResponse> GetListMultipleTrackAsync(MultipleTrackRequest request);
         Task PutSaveTracks(SaveTracksRequest request);
+        Task<TrackResponse> GetById(TrackRequest request);
     }
 }

NemAnCore/Services/StatsClientService.cs

         {
             _serviceClient = channel.CreateGrpcService<IStatsService>();
         }
-        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
+        public async Task<CurrentTrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
     {
             return await _serviceClient.GetCurrentlyPlayingTrack(token);
         }

NemAnCore/Services/TrackClientService.cs

 using GrpcShared.DTO.Track.MultipleTrack;
 using GrpcShared.DTO.Track.SaveTracks;
 using GrpcShared.DTO.Track.SingleTrack;
+using GrpcShared.DTO.TrackByID;
 using GrpcShared.Interfaces;
 using NemAnBlazor.Services.Interfaces;
 using ProtoBuf.Grpc.Client;
         {
              await _serviceClient.SaveTracks(request);
         }
+        public async Task<TrackResponse> GetById(TrackRequest request)
+        {
+            return await _serviceClient.GetById(request);
+        }
     }
 }

gRPCServer/Services/StatsService.cs

             _httpClientFactory = httpClientFactory;
         }
 
-        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
+        public async Task<CurrentTrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
         {
             var client = _httpClientFactory.CreateClient("HttpClient");
             client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + token.Token);
             
             var searchResult = await client.GetAsync($"me/player/currently-playing");
 
-            var responses = JsonConvert.DeserializeObject<TrackResponse>(await searchResult.Content.ReadAsStringAsync())!;
+            var responses = JsonConvert.DeserializeObject<CurrentTrackResponse>(await searchResult.Content.ReadAsStringAsync())!;
 
            return responses;
 

gRPCServer/Services/TrackService.cs

 using GrpcShared.DTO.Track.MultipleTrack;
 using GrpcShared.DTO.Track.SaveTracks;
 using GrpcShared.DTO.Track.SingleTrack;
+using GrpcShared.DTO.TrackByID;
 using GrpcShared.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.Net.Http.Headers;
             sb.Length = sb.Length - 3;
             return sb.ToString();
         }
+
+        public async Task<TrackResponse> GetById(TrackRequest request)
+        {
+            var client = _httpClientFactory.CreateClient("HttpClient");
+
+            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);
+            var track = await client.GetAsync($"tracks/{request.TrackID}");
+
+             var response = JsonConvert.DeserializeObject<TrackResponse>(await track!.Content.ReadAsStringAsync())!;
+            return response;
+        }
     }
 }