minor bug fixes

GrpcShared/DTO/Db/UserResponse.cs

         public string Id { get; set; }
         [ProtoMember(2)]
         public string Token { get; set; }
+        [ProtoMember(3)]
+        public string RefreshToken{ get; set; }
     }
 }

GrpcShared/DTO/VoidMessage.cs

     [ProtoContract]
     public class VoidMessage
     {
+        [ProtoMember(1)]
+        public string InsertedId { get; set; }
+       
     }
 }

GrpcShared/Interfaces/IIdentityService.cs

         Task<VoidMessage> DeleteTrackAsync(DbRequestMessage id);
         Task<VoidMessage> SaveUserAsync(UserResponse user);
         Task<VoidMessage> DeleteUserAsync(DbRequestMessage user);
+        Task<VoidMessage> UpdateTokenAsync (UserResponse user);
     }
 }

IdentityProvider/Models/UserModel.cs

         [BsonRepresentation(BsonType.ObjectId)]
         public string Id { get; set; }
         public string Token { get; set; }
+        public string RefreshToken { get; set; }
     }
 }

IdentityProvider/Properties/launchSettings.json

-{
+{
   "iisSettings": {
     "windowsAuthentication": false,
     "anonymousAuthentication": true,
   "profiles": {
     "IIS Express": {
       "commandName": "IISExpress",
-      "launchBrowser": true,
-      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
-      }
+      },
+      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}"
     },
     "IdentityProvider": {
       "commandName": "Project",
-      "dotnetRunMessages": "true",
       "launchBrowser": true,
-      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
-      "applicationUrl": "https://localhost:5001;http://localhost:5000",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
-      }
+      },
+      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "dotnetRunMessages": "true"
     }
   }
-}
+}

IdentityProvider/Services/IdentityService.cs

         public async Task<UserResponse> GetTokenByIdAsync(DbRequestMessage request)
         {
             UserModel user = await _userCollection.Find(u => u.Id == request.Id).FirstOrDefaultAsync();
-            return new UserResponse
-            {
-                Id = user.Id,
-                Token = user.Token
-            };
+            if (user != null)
+                return new UserResponse
+                {
+                    Id = user.Id,
+                    Token = user.Token
+                };
+            else return new UserResponse();
         }
         public async Task<TrackResponse> GetTrackByUserAsync(DbRequestMessage request)
         {
 
             TrackModel trackModel = new()
             {
+                Id = track.Id,
                 Title = track.Title,
                 Album = track.Album,
                 Artist = track.Artist,
                 TrackId = track.TrackId
             };
             //first check if there's already a song in the db, if yes, update the row
-            var song = await _trackCollection.Find(x => x.UserId == track.UserId).AnyAsync();
+            bool song = await _trackCollection.Find(x => x.UserId == track.UserId).AnyAsync();
 
-            if (song) await _trackCollection.ReplaceOneAsync(x => x.UserId == track.UserId, trackModel);
+            if (song) await _trackCollection.DeleteOneAsync(s => s.UserId == track.UserId);
 
-            else await _trackCollection.InsertOneAsync(trackModel);
+            await _trackCollection.InsertOneAsync(trackModel);
 
-            return new VoidMessage();
+            return new VoidMessage() { InsertedId = trackModel.Id };
 
 
         }
         public async Task<VoidMessage> SaveUserAsync(UserResponse userRequest)
         {
             bool user = await _userCollection.Find(x => x.Id == userRequest.Id).AnyAsync();
-            if (!user) await _userCollection.InsertOneAsync(new UserModel
+
+            UserModel tempUser = new()
             {
-                Token = userRequest.Token
-            });
-            return new VoidMessage();
+                Token = userRequest.Token,
+                RefreshToken = userRequest.RefreshToken
+            };
+
+            if (!user) await _userCollection.InsertOneAsync(tempUser);
+
+            return new VoidMessage() { InsertedId = tempUser.Id };
+
         }
         public async Task<VoidMessage> DeleteTrackAsync(DbRequestMessage request)
         {
             return new VoidMessage();
         }
 
+        public async Task<VoidMessage> UpdateTokenAsync(UserResponse user)
+        {
 
+            UserModel dbUser = await _userCollection.Find(x => x.Id == user.Id).FirstOrDefaultAsync();
+            if (dbUser.Id != null)
+            {
+                dbUser.Token = user.Token;
+                dbUser.RefreshToken = user.RefreshToken;
+                await _userCollection.ReplaceOneAsync(x => x.Id == user.Id, dbUser);
+            }
 
+            return new VoidMessage
+            {
+                InsertedId = dbUser.Id
+            };
+        }
     }
 }

NemAnCore/Pages/Callback.razor

 @page "/callback"
+@using GrpcShared.DTO
+@using GrpcShared.DTO.Db
 @using NemAnBlazor.Services.Interfaces
 @inject NavigationManager NavigationMgr
 @inject IAuthClientService AuthService
 @inject Blazored.LocalStorage.ILocalStorageService localStorage
+@inject IIdentityClientService identityService
+
 <PageTitle>Redirecting...</PageTitle>
 
 
         //if (response.access_token == null) NavigationMgr.NavigateTo("/");
 
         //store access token in local storage
-        await localStorage.SetItemAsync("token", response.AccessToken);
-        await localStorage.SetItemAsync("refresh_token", response.RefreshToken);
-        
+        //await localStorage.SetItemAsync("token", response.AccessToken);
+        //await localStorage.SetItemAsync("refresh_token", response.RefreshToken);
+        //UserResponse user = new();
+        //await identityService.SaveUserAsync(new GrpcShared.DTO.Db.UserResponse());
+        string userId = await localStorage.GetItemAsync<string>("user_info");
+         
+       if(userId == null)
+        {
+            VoidMessage userRes = await identityService.SaveUserAsync(new GrpcShared.DTO.Db.UserResponse { RefreshToken = response.RefreshToken , Token = response.AccessToken});
+           
+            if (userRes.InsertedId != null)
+                await localStorage.SetItemAsync<string>("user_info", userRes.InsertedId);
+           
+        }        
         //redirect to home
         NavigationMgr.NavigateTo("/home");
     }

NemAnCore/Pages/FetchData.razor

 @inject Blazored.LocalStorage.ILocalStorageService localStorage
 @inject ITrackClientService SearchService
 @inject IAuthClientService AuthService
+@inject IIdentityClientService identityService
 
 
 <PageTitle>Search</PageTitle>
     private async Task Click()
     {
 
-        var token = await localStorage.GetItemAsync<string>("token");
-        string refreshT = await localStorage.GetItemAsync<string>("refresh_token");
+        var userInfo = await localStorage.GetItemAsync<string>("user_info");
 
-        TokenMessage tokenM = new TokenMessage { Token = token, RefreshToken = refreshT };
+        var user = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
+            {
+                Id = userInfo
+            });
+
+        TokenMessage tokenM = new TokenMessage { Token = user.Token, RefreshToken = user.RefreshToken };
 
-        SearchRequest request = new() { Query = "aitch", Type = "track", Token = token };
+        SearchRequest request = new() { Query = "aitch", Type = "track", Token = user.Token };
 
         try
         {
 
             if (searchResponse.ResponseMsg == System.Net.HttpStatusCode.Unauthorized)
             {
-                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, tokenM, localStorage);
-                token = tempToken == null ? token : tempToken;
+                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, tokenM, user, localStorage, identityService);               
             }
         }
         catch (RpcException e)

NemAnCore/Pages/Home.razor

 @page "/home"
 @using Grpc.Core
 @using GrpcShared.DTO
+@using GrpcShared.DTO.Db
 @using GrpcShared.DTO.Track
 @using NemAnBlazor.Services.Interfaces
 @using System.Net
 @inject IStatsClientService spotifyService
 @inject ITrackClientService trackService
 @inject IAuthClientService AuthService
+@inject NavigationManager NavigationMgr
 @inject IIdentityClientService identityService
 
 <h3>Home</h3>
     protected override async Task OnInitializedAsync()
     {
         CurrentTrackResponse track;
-        string tokenS = await localStorage.GetItemAsync<string>("token");
-        string refreshT = await localStorage.GetItemAsync<string>("refresh_token");
+        string tokenS = "", refreshT = "";
+        string userId = await localStorage.GetItemAsync<string>("user_info");
 
-        //tokenS = "BQBMgFm6jnFNWWeZEMGIRP_f-ENPid7Kw8JubAyuWAe4JK0S1DPFGlaAdZ_Fey6ePkCnz8-cqC0oyRmrciWUy5ISUTQKDe8PTQn4iBRMYCgM0n4GnS1xAErHJcm4Vpu2TAngk-4vQUOfTQRcedNTfCaHKP4uFJgTlTI7JHGrtB-_EZLnFcZ2OQe31oFQIJ1wM3ZtvwnN";
-        TokenMessage token = new TokenMessage { Token = tokenS, RefreshToken = refreshT };
+        if (userId != null)
+        {
+            //get token from identity
+            var userResponse = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage { Id = userId });
+
+            if (userResponse != null)
+            {
+                tokenS = userResponse.Token;
+                refreshT = userResponse.RefreshToken;
+            }
+            else {
+                await localStorage.RemoveItemAsync("user_info");
+                NavigationMgr.NavigateTo("/");
+            }
+        }
 
+        
+        //tokenS = "BQBMgFm6jnFNWWeZEMGIRP_f-ENPid7Kw8JubAyuWAe4JK0S1DPFGlaAdZ_Fey6ePkCnz8-cqC0oyRmrciWUy5ISUTQKDe8PTQn4iBRMYCgM0n4GnS1xAErHJcm4Vpu2TAngk-4vQUOfTQRcedNTfCaHKP4uFJgTlTI7JHGrtB-_EZLnFcZ2OQe31oFQIJ1wM3ZtvwnN";
+        TokenMessage token = new() { Token = tokenS, RefreshToken = refreshT };
+        UserResponse user = new() { Id = userId, RefreshToken = refreshT };
         try
         {
             track = await spotifyService.GetCurrentlyPlayingTrack(token);
             //if token expired, refresh it
             if (track.ResponseMsg == System.Net.HttpStatusCode.Unauthorized)
             {
-                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, token, localStorage);
+                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, token, user, localStorage, identityService);
                 tokenS = tempToken == null ? tokenS : tempToken;
                 //if refreshed token is null, that means that refresh token was invalid, so you should redirect to login
             }
 
             if (items.ResponseMsg == System.Net.HttpStatusCode.Unauthorized)
             {
-                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, token, localStorage);
+                string? tempToken = await SpotifyHelper.TryRefreshToken(AuthService, token, user, localStorage, identityService);
                 tokenS = tempToken == null ? tokenS : tempToken;
             }
         }
             throw;
         }
 
-        //await identityService.SaveUserAsync(new GrpcShared.DTO.Db.UserResponse
-        //    {
-        //        Token = tokenS
-        //    });
 
         await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
             {
                 Title = track.Item.Name,
                 Album = track.Item.Album.Name,
                 Artist = track.Item.Artists[0].Name,
-                UserId = "630748c8d149033aaf5a774a"
+                UserId = userId
             });
 
         //var resp = await identityService.ListUsersAsync(new VoidMessage());
 
-        //var tokenFromDb = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
-        //    {
-        //        Id = "63074188426efd486fadd74d"
-        //    });
+        var tokenFromDb = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
+            {
+                Id = userId
+            });
 
-        //var trackByUser = await identityService.GetTrackByUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
-        //    {
-        //        Id = "63074188426efd486fadd74d"
-        //    });
+        var trackByUser = await identityService.GetTrackByUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
+            {
+                Id = userId
+            });
         //await identityService.DeleteTrackAsync(new GrpcShared.DTO.Db.DbRequestMessage
         //    {
-        //        Id = "630743c91631901f903f9254"
-        //    });
-        //  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 = "63074188426efd486fadd74d"
+        //        Id =
         //    });
-        //find id from local storage
-            await identityService.DeleteUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
+        await identityService.SaveTrackAsync(new GrpcShared.DTO.Db.SaveTrackRequest
             {
-                Id = "630748c8d149033aaf5a774a"
+
+                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
+        //    {
+        //        Id = userId
+        //    });
     }
 }

NemAnCore/Pages/Login.razor

 @inject IAuthClientService AuthService
 @inject ITrackClientService SearchService
 @using System.Security.Claims
+@inject Blazored.LocalStorage.ILocalStorageService localStorage
 
 
         
 @code {
     private string? message;
 
+    protected override async Task OnInitializedAsync()
+    {
+        var userId = await localStorage.GetItemAsync<string>("user_info");
+        if (userId != null) NavigationManager.NavigateTo("/home");
 
+    }
     private async Task LoginUser()
     {
         //var response = await SearchService.GetListSearchAsync(new GrpcShared.DTO.Search.SearchRequest() { Query="venom", Type = "track"});

NemAnCore/Services/IdentityClientService.cs

         {
             return await _serviceClient.SaveUserAsync(user);
         }
+
+        public async Task<VoidMessage> UpdateTokenAsync(UserResponse user)
+        {
+            return await _serviceClient.UpdateTokenAsync(user);
+        }
     }
 }

NemAnCore/Services/Interfaces/IIdentityClientService.cs

         Task<VoidMessage> DeleteTrackAsync(DbRequestMessage id);
         Task<VoidMessage> SaveUserAsync(UserResponse user);
         Task<VoidMessage> DeleteUserAsync(DbRequestMessage user);
+        Task<VoidMessage> UpdateTokenAsync(UserResponse user);
     }
 }

NemAnCore/SpotifyHelper.cs

 using Blazored.LocalStorage;
 using GrpcShared.DTO;
+using GrpcShared.DTO.Db;
 using NemAnBlazor.Services.Interfaces;
 
 namespace NemAnBlazor
 {
     public static class SpotifyHelper
     {
-        public static async Task<string?> TryRefreshToken(IAuthClientService authService, TokenMessage msg, ILocalStorageService localStorage)
+        public static async Task<string?> TryRefreshToken
+        (IAuthClientService authService,
+        TokenMessage msg,UserResponse user,
+        ILocalStorageService localStorage,
+        IIdentityClientService identityService)
         {
             var refreshResponse = await authService.RefreshAccessToken(msg);
 
             if (refreshResponse.AccessToken != null)
             {
-                await localStorage.SetItemAsync<string>("token", refreshResponse.AccessToken);
+                await identityService.UpdateTokenAsync(new UserResponse
+                {
+                    Id = user.Id,
+                    Token = refreshResponse.AccessToken,
+                    RefreshToken = user.RefreshToken
+                });
                 return refreshResponse.AccessToken;
             }
             else return null;

SpotifyWorker/SpotifyWorker.csproj

     <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.1" />
     <PackageReference Include="protobuf-net.Grpc" Version="1.0.171" />
   </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\gRPCServer\SpotifyService.csproj" />
+    <ProjectReference Include="..\IdentityProvider\IdentityProvider.csproj" />
+  </ItemGroup>
 </Project>

SpotifyWorker/Worker.cs

     public class Worker : BackgroundService
     {
         private readonly ILogger<Worker> _logger;
-
+        private HttpClient _httpClient;
         public Worker(ILogger<Worker> logger)
         {
             _logger = logger;
         }
-
+        public override Task StartAsync(CancellationToken cancellationToken)
+        {
+            _httpClient = new HttpClient();
+            return base.StartAsync(cancellationToken);
+        }
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
-                await Task.Delay(1000, stoppingToken);
+               
+                await Task.Delay(5000, stoppingToken);
             }
         }
     }