fixed token storing and refactored some code

GrpcShared/DTO/Search/SearchRequest.cs

 
         [ProtoMember(2)]
         public string? Type  { get; set; }
-
-        [ProtoMember(3)]
-        public string? Include_External { get; set; }
-
-        [ProtoMember(4)]
-        public int? Limit { get; set; }
-
-        [ProtoMember(5)]
-        public int? Offset { get; set; }
-       
+   
     }
 }

GrpcShared/DTO/Search/SearchResponse.cs

             public string? Name { get; set; }
 
             [ProtoMember(5)]
-            public DateTimeOffset? ReleaseDate { get; set; }
+            public string? ReleaseDate { get; set; }
 
             [ProtoMember(6)]
             public int? TotalTracks { get; set; }

IdentityProvider/Program.cs

 using Microsoft.Extensions.Options;
 using GrpcShared.DTO.Auth;
 using SpotifyService.Services;
-using Blazored.SessionStorage;
+using Blazored.LocalStorage;
 
 var builder = WebApplication.CreateBuilder(args);
 #if DEBUG
 builder.Services.AddGrpc();
 builder.Services.AddCodeFirstGrpc();
 builder.Services.AddCodeFirstGrpcReflection();
-builder.Services.AddBlazoredSessionStorage();
+builder.Services.AddBlazoredLocalStorage();
 //call spotify api
 builder.Services.AddHttpClient();
 

IdentityProvider/Services/AuthService.cs

 //using IdentityProvider.Protos.AuthService;
-using Blazored.SessionStorage;
+using Blazored.LocalStorage;
 using Grpc.Net.Client;
 using GrpcShared;
 using GrpcShared.DTO;

NemAnCore/NemAnBlazor.csproj

   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Blazored.SessionStorage" Version="2.2.0" />
+    <PackageReference Include="Blazored.LocalStorage" Version="4.2.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.47.0" />
     <PackageReference Include="Grpc.Net.Client.Web" Version="2.47.0" />
     <PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="6.0.8" />

NemAnCore/Pages/Callback.razor

 @using NemAnBlazor.Services.Interfaces
 @inject NavigationManager NavigationMgr
 @inject IAuthClientService AuthService
-@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
+@inject Blazored.LocalStorage.ILocalStorageService localStorage
 <PageTitle>Redirecting...</PageTitle>
 
 
         //if (response.access_token == null) NavigationMgr.NavigateTo("/");
 
         //store access token in local storage
-        await sessionStorage.SetItemAsync("token", response.AccessToken);
-        await sessionStorage.SetItemAsync("refresh_token", response.RefreshToken);
+        await localStorage.SetItemAsync("token", response.AccessToken);
+        await localStorage.SetItemAsync("refresh_token", response.RefreshToken);
         
         //redirect to home
         NavigationMgr.NavigateTo("/home");

NemAnCore/Pages/FetchData.razor

 @using NemAnBlazor.Services.Interfaces
 @using System.Diagnostics
 @*@inject HttpClient Http*@
-@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
+@inject Blazored.LocalStorage.ILocalStorageService localStorage
 @inject ITrackClientService SearchService
 @inject IAuthClientService AuthService
 
     private async Task Click()
     {
 
-        var token = await sessionStorage.GetItemAsync<string>("token");
+        var token = await localStorage.GetItemAsync<string>("token");
         TokenMessage tm = new() { Token = token };
         SearchRequest request = new() { Query = "aitch", Type = "track", Token = token };
         SearchResponse searchResponse = await SearchService.GetListSearchAsync(request);

NemAnCore/Pages/Home.razor

 @using GrpcShared.DTO
 @using GrpcShared.DTO.Track
 @using NemAnBlazor.Services.Interfaces
-@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
+@inject Blazored.LocalStorage.ILocalStorageService localStorage
 @inject IStatsClientService spotifyService
 @inject ITrackClientService trackService
 
 @code {
     protected override async Task OnInitializedAsync()
     {
-        string tokenS = await sessionStorage.GetItemAsync<string>("token");
+        string tokenS = await localStorage.GetItemAsync<string>("token");
         TokenMessage token = new TokenMessage{Token = tokenS};
 
          CurrentTrackResponse response = await spotifyService.GetCurrentlyPlayingTrack(token);

NemAnCore/Program.cs

 global using Microsoft.AspNetCore.Components.Authorization;
-using Blazored.SessionStorage;
+using Blazored.LocalStorage;
 using Grpc.Net.Client;
 using Grpc.Net.Client.Web;
 using Microsoft.AspNetCore.Components;
 builder.Services.AddScoped<ITrackClientService, TrackClientService>();
 builder.Services.AddScoped<IAuthClientService, AuthClientService>();
 builder.Services.AddScoped<IStatsClientService, StatsClientService>();
-builder.Services.AddBlazoredSessionStorage();
+builder.Services.AddBlazoredLocalStorage(); 
 builder.Services.AddScoped<AuthenticationStateProvider, AuthClientService>();
 builder.Services.AddAuthorizationCore();
 

NemAnCore/Services/AuthClientService.cs

 using GrpcShared.DTO;
 using System.Security.Claims;
 using Microsoft.AspNetCore.Components.Authorization;
-using Blazored.SessionStorage;
+using Blazored.LocalStorage;
 
 namespace NemAnBlazor.Services
 {
     {
 
         private IAuthService _serviceClient;
-        private ISessionStorageService _sessionStorage;
-        public AuthClientService(GrpcChannel grpcChannel, ISessionStorageService sessionStorage)
+        private ILocalStorageService _sessionStorage;
+        public AuthClientService(GrpcChannel grpcChannel, ILocalStorageService sessionStorage)
         {
             _serviceClient = grpcChannel.CreateGrpcService<IAuthService>();
             _sessionStorage = sessionStorage;

gRPCServer/HttpUtils/HttpUtils.cs

             return response;
 
         }
+        public static async Task PutData(HttpClient client, string url, string token)
+        {
+            //add header 
+            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + token);
+
+            //get request
+            await client.PutAsync(url, null);
+
+        }
+
     }
 }

gRPCServer/Services/TrackService.cs

         {
             var client = _httpClientFactory.CreateClient("HttpClient");
 
-            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);
-
             var param = new Dictionary<string, List<string>>();
             param["ids"] = request.Ids!;
 
             var query = UriUtil(param);
+            string url = $"me/tracks/{query}";
 
-
-            await client.PutAsync($"me/tracks/{query}", null); 
-
-
+            //the response type has nothing to do with the method, it's there so that the method can be called
+            await HttpUtils.HttpUtils<MultipleTrackResponse>.PutData(client, url, request.Token!);
+ 
         }
         public static string UriUtil(Dictionary<string, List<string>> param)
         {