http config

IdentityProvider/Program.cs

 //call spotify api
 builder.Services.AddHttpClient();
 
-builder.Services.AddSingleton<SpotifyDbConfig>();
+//builder.Services.AddSingleton<SpotifyDbConfig>();
 
 builder.Services.Configure<SpotifyDbConfig>(
     builder.Configuration.GetSection("SpotifyDb"));

IdentityProvider/appsettings.json

   "AllowedHosts": "*",
   "Kestrel": {
     "EndpointDefaults": {
-      "Protocols": "Http1AndHttp2"
+      "Protocols": "Http2"
     }
   },
   "SpotifyDb": {

NemAnCore/Pages/Home.razor

         TokenMessage token = new() { Token = tokenS, RefreshToken = refreshT };
         UserResponse user = new() { Id = userId, RefreshToken = refreshT };
       
-            track = await spotifyService.GetCurrentlyPlayingTrack(new SessionMessage { UserId = userId });
+            //track = await spotifyService.GetCurrentlyPlayingTrack(new SessionMessage { UserId = userId });
 
           
        
 
         //var trackById = await trackService.GetById(new GrpcShared.DTO.TrackByID.TrackRequest { TrackID = "4fy1A2WBTPX55mUI16TQXa", Token = tokenS });
        
-            var items = await spotifyService.GetTopItems(new GrpcShared.DTO.TopItem.TopItemRequest { UserId = userId, IsTracks = false, Offset = 5 });
+            //var items = await spotifyService.GetTopItems(new GrpcShared.DTO.TopItem.TopItemRequest { UserId = userId, IsTracks = false, Offset = 5 });
 
       
-        await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
-            {
-                TrackId = track.Item!.Id!,
-                Title = track.Item!.Name!,
-                Album = track.Item.Album!.Name!,
-                Artist = track.Item.Artists![0].Name!,
-                UserId = userId!
-            });
+        //await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
+        //    {
+        //        TrackId = track.Item!.Id!,
+        //        Title = track.Item!.Name!,
+        //        Album = track.Item.Album!.Name!,
+        //        Artist = track.Item.Artists![0].Name!,
+        //        UserId = userId!
+        //    });
 
         //var resp = await identityService.ListUsersAsync(new VoidMessage());
 
-        var tokenFromDb = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
-            {
-                Id = userId!
-            });
+        //var tokenFromDb = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
+        //    {
+        //        Id = userId!
+        //    });
 
-        var trackByUser = await identityService.GetTrackByUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
-            {
-                Id = userId!
-            });
+        //var trackByUser = await identityService.GetTrackByUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
+        //    {
+        //        Id = userId!
+        //    });
         //await identityService.DeleteTrackAsync(new GrpcShared.DTO.Db.DbRequestMessage
         //    {
         //        Id =
         //    });
-        await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
-            {
+        //await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
+        //    {
 
-                TrackId = track.Item.Id!,
-                Title = track.Item.Name!,
-                Album = track.Item.Album.Name!,
-                Artist = track.Item.Artists[0].Name!,
-                UserId = userId!
-            });
+        //        TrackId = track.Item.Id!,
+        //        Title = track.Item.Name!,
+        //        Album = track.Item.Album.Name!,
+        //        Artist = track.Item.Artists[0].Name!,
+        //        UserId = userId!
+        //    });
         //find id from local storage
         //await identityService.DeleteUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
         //    {

SpotifyWorker/Program.cs

+using Grpc.Net.Client;
+using Grpc.Net.Client.Web;
+using GrpcShared.Interfaces;
+using SpotifyService.Services;
 using SpotifyWorker;
 
+
 IHost host = Host.CreateDefaultBuilder(args)
     .ConfigureServices(services =>
     {
         services.AddHostedService<Worker>();
+      
     })
     .Build();
 
+
 await host.RunAsync();

SpotifyWorker/SpotifyWorker.csproj

   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Google.Protobuf" Version="3.21.5" />
+    <PackageReference Include="Grpc" Version="2.46.3" />
+    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.48.0" />
+    <PackageReference Include="Grpc.Tools" Version="2.48.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.1" />
     <PackageReference Include="protobuf-net.Grpc" Version="1.0.171" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
   </ItemGroup>
 
   <ItemGroup>

SpotifyWorker/Worker.cs

+using Grpc.Core;
+using Grpc.Net.Client;
+using GrpcShared.Interfaces;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Server.Kestrel.Core;
+using ProtoBuf.Grpc.Client;
+using SpotifyService.Services;
+
 namespace SpotifyWorker
 {
     public class Worker : BackgroundService
     {
         private readonly ILogger<Worker> _logger;
-        private HttpClient? _httpClient;
+  
+        private IStatsService _serviceClient;
         public Worker(ILogger<Worker> logger)
         {
             _logger = logger;
+            // AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
+            _serviceClient = GrpcChannel.ForAddress("https://localhost:5051/").CreateGrpcService<IStatsService>();
         }
-        public override Task StartAsync(CancellationToken cancellationToken)
-        {
-            _httpClient = new HttpClient();
-            return base.StartAsync(cancellationToken);
-        }
+        //public override  Task StartAsync(CancellationToken cancellationToken)
+        //{          
+        //    return  base.StartAsync(cancellationToken);
+        //}
+        //public class GrpcServerStartup
+        //{
+        //    public void ConfigureServices(IServiceCollection services)
+        //    {
+        //        services.AddGrpc();
+        //        //services.AddTransient<IStatsService, StatsService>();
+        //    }
+
+        //    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        //    {
+        //        app.UseRouting();
+
+        //        app.UseEndpoints(endpoints =>
+        //        {
+        //            endpoints.MapGrpcService<StatsService>();
+        //        });
+        //    }
+        //}
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             while (!stoppingToken.IsCancellationRequested)
             {
-                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
-               
+                // await Host.CreateDefaultBuilder()
+                //.ConfigureWebHostDefaults(builder =>
+                //{
+                //    builder
+                //        .ConfigureKestrel(options =>
+                //        {
+                //            options.ListenAnyIP(0, listenOptions =>
+                //            {
+                //                listenOptions.Protocols = HttpProtocols.Http2;
+                //            });
+                //        })
+                //        .UseKestrel()
+                //        .UseStartup<GrpcServerStartup>();
+                //})
+                //.Build()
+                //.StartAsync(stoppingToken);
+                //await _statsService.GetCurrentlyPlayingTrack(new GrpcShared.DTO.SessionMessage { UserId = "6308a8bfc731f7b44d76ac4e" });
+                //var result = await _httpClient.GetAsync("url");
+                //_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                 await Task.Delay(5000, stoppingToken);
+                try
+                {
+                    var res = await _serviceClient.GetCurrentlyPlayingTrack(new GrpcShared.DTO.SessionMessage { UserId = "6308a8bfc731f7b44d76ac4e" });
+
+                }
+                catch (RpcException e)
+                {
+                    if (e.StatusCode == StatusCode.Cancelled)
+                    {
+                        return;
+                    }
+                    Console.WriteLine(e.Message);
+                    throw;
+                }
+               
+                //res = await _serviceClient.GetCurrentlyPlayingTrack(new GrpcShared.DTO.SessionMessage { UserId = "6308a8bfc731f7b44d76ac4e" });
+
+
             }
         }
     }

gRPCServer/GLOBALS.cs

     {
         public const String SPOTIFYURL = "https://api.spotify.com/v1/";
         public const String MEDIATYPE = "application/json";
+        public const string CLIENT_ID = "83e1d09876b049c4bb1953185a4b3bfb";
+        public const string SECRET = "ea752433d0774fad87fab5c1ee788c8d";
+        public const string REDIRECT_URI = "http://localhost:5051/callback";
+        public const string SCOPE = "user-read-currently-playing user-read-email user-library-modify user-top-read user-read-private";
+        /*
+          "ClientId": "83e1d09876b049c4bb1953185a4b3bfb",
+    "RedirectURI": "https://localhost:44342/callback",
+    "Scope": "user-read-currently-playing user-read-email user-library-modify user-top-read user-read-private",
+    "ClientSecret": "ea752433d0774fad87fab5c1ee788c8d"
+         */
     }
 }

gRPCServer/Services/AuthService.cs

             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();
+            //var secrets = await GetAuthParams();
+            var secrets = new CodeRequest {
+                ClientId = GLOBALS.CLIENT_ID ,
+                ClientSecret = GLOBALS.SECRET,
+                RedirectURI = GLOBALS.REDIRECT_URI
+            };
             byte[] contentType = Encoding.UTF8.GetBytes($"{secrets.ClientId}:{secrets.ClientSecret}");
             tokenRequest.RedirectUri = secrets.RedirectURI;
 
             requestBody["refresh_token"] = tokenM.RefreshToken!;
             requestBody["grant_type"] = "refresh_token";
 
-            var secrets = await GetAuthParams();
+            //var secrets = await GetAuthParams();
+            var secrets = new CodeRequest
+            {
+                ClientId = GLOBALS.CLIENT_ID,
+                ClientSecret = GLOBALS.SECRET,
+                RedirectURI = GLOBALS.REDIRECT_URI
+            };
             byte[] contentType = Encoding.UTF8.GetBytes($"{secrets.ClientId}:{secrets.ClientSecret}");
 
             //AUTHORIZATION HEADER

gRPCServer/appsettings.json

   "AllowedHosts": "*",
   "Kestrel": {
     "EndpointDefaults": {
-      "Protocols": "Http1AndHttp2"
+      "Protocols": "Http2"
     }
   },
   "AuthParams": {
     "ClientId": "83e1d09876b049c4bb1953185a4b3bfb",
-    "RedirectURI": "https://localhost:44342/callback",
+    "RedirectURI": "http://localhost:5051/callback",
     "Scope": "user-read-currently-playing user-read-email user-library-modify user-top-read user-read-private",
     "ClientSecret": "ea752433d0774fad87fab5c1ee788c8d"
   }