tested endpoints and fixed minor bugs

GrpcShared/DTO/Db/TrackResponse.cs

     public class TrackResponse
     {
         [ProtoMember(1)]
-        public string Id { get; set; }
+        public string Id { get; set; }     
         [ProtoMember(2)]
         public string Title { get; set; }
         [ProtoMember(3)]
         public string Artist { get; set; }
         [ProtoMember(4)]
         public string Album { get; set; }
+        [ProtoMember(5)]
+        public string TrackId { get; set; }
     }
 }

IdentityProvider/Models/SpotifyDbConfig.cs

 {
     public class SpotifyDbConfig
     {
-        public string ConnString { get; set; } = null!;
-        public string DBName { get; set; } = null!;
+        public string ConnectionString { get; set; } = null!;
+        public string DatabaseName { get; set; } = null!;
         public string UserCollection { get; set; } = null!;
-        public string TrackCollection { get; set; } = null!;
+        public string TracksCollection { get; set; } = null!;
     }
 }

IdentityProvider/Models/TrackModel.cs

         public string Artist { get; set; }
         public string Album { get; set; }
         public string UserId { get; set; }
+        public string TrackId { get; set; }
     }
 }

IdentityProvider/Program.cs

 using GrpcShared.DTO.Auth;
 using Blazored.LocalStorage;
 using IdentityProvider.Models;
+using IdentityProvider.Services;
 
 var builder = WebApplication.CreateBuilder(args);
 #if DEBUG
 app.MapGrpcService<AuthService>().EnableGrpcWeb();
 app.MapGrpcService<TrackService>().EnableGrpcWeb();
 app.MapGrpcService<StatsService>().EnableGrpcWeb();
+app.MapGrpcService<IdentityService>().EnableGrpcWeb();
 
 app.MapCodeFirstGrpcReflectionService();
 

IdentityProvider/Services/IdentityService.cs

         private readonly IMongoCollection<TrackModel> _trackCollection;
         public IdentityService(IOptions<SpotifyDbConfig> spotifyDbConfig)
         {
-            var mongoClient = new MongoClient(spotifyDbConfig.Value.ConnString);
-            var mongoDbContext = mongoClient.GetDatabase(spotifyDbConfig.Value.DBName);
+            var mongoClient = new MongoClient(spotifyDbConfig.Value.ConnectionString);
+            var mongoDbContext = mongoClient.GetDatabase(spotifyDbConfig.Value.DatabaseName);
             _userCollection = mongoDbContext.GetCollection<UserModel>(spotifyDbConfig.Value.UserCollection);
-            _trackCollection = mongoDbContext.GetCollection<TrackModel>(spotifyDbConfig.Value.TrackCollection);
+            _trackCollection = mongoDbContext.GetCollection<TrackModel>(spotifyDbConfig.Value.TracksCollection);
         }
 
 
         {
             List<UserModel> users = await _userCollection.Find(_ => true).ToListAsync();
             //map users to match the grpc response
-            return users.Select(u => new UserResponse
+            var usersRes = users.Select(u => new UserResponse
             {
                 Id = u.Id,
                 Token = u.Token
             }).ToList();
+            return usersRes;
         }
         public async Task<UserResponse> GetTokenByIdAsync(DbRequestMessage request)
         {
                 Id = track.Id,
                 Album = track.Album,
                 Artist = track.Artist,
-                Title = track.Title
+                Title = track.Title,
+                TrackId = track.TrackId
             };
         }
         public async Task<VoidMessage> SaveTrackAsync(SaveTrackRequest track)
                 Title = track.Title,
                 Album = track.Album,
                 Artist = track.Artist,
-                UserId = track.UserId
+                UserId = track.UserId,
+                TrackId = track.TrackId
             };
             //first check if there's already a song in the db, if yes, update the row
-            var song = await _trackCollection.FindAsync(x => x.UserId == track.UserId);
+            var song = await _trackCollection.Find(x => x.UserId == track.UserId).AnyAsync();
 
-            if (song != null) await _trackCollection.ReplaceOneAsync(x => x.UserId == track.UserId, trackModel);
+            if (song) await _trackCollection.ReplaceOneAsync(x => x.UserId == track.UserId, trackModel);
 
             else await _trackCollection.InsertOneAsync(trackModel);
 
 
 
         }
-        public async Task<VoidMessage> SaveUserAsync(UserResponse user)
+        public async Task<VoidMessage> SaveUserAsync(UserResponse userRequest)
         {
-            await _userCollection.InsertOneAsync(new UserModel
+            bool user = await _userCollection.Find(x => x.Id == userRequest.Id).AnyAsync();
+            if (!user) await _userCollection.InsertOneAsync(new UserModel
             {
-                Id = user.Id,
-                Token = user.Token
+                Token = userRequest.Token
             });
             return new VoidMessage();
         }
             await _trackCollection.DeleteOneAsync(x => x.Id == request.Id);
             return new VoidMessage();
         }
-        public async Task<VoidMessage> DeleteUserAsync(DbRequestMessage user)
+        public async Task<VoidMessage> DeleteUserAsync(DbRequestMessage userRequest)
         {
-            await _userCollection.DeleteOneAsync(x => x.Id == user.Id);
+            //check if user exists
+            bool user = await _userCollection.Find(x => x.Id == userRequest.Id).AnyAsync();
+            //delete track related to him
+            if (user)
+            {
+                await _trackCollection.DeleteManyAsync(x => x.UserId == userRequest.Id);
+                //delete user
+                await _userCollection.DeleteOneAsync(x => x.Id == userRequest.Id);
+            }
             return new VoidMessage();
         }
 

NemAnCore/Pages/Home.razor

 @code {
     protected override async Task OnInitializedAsync()
     {
-
+        CurrentTrackResponse track;
         string tokenS = await localStorage.GetItemAsync<string>("token");
         string refreshT = await localStorage.GetItemAsync<string>("refresh_token");
 
 
         try
         {
-            CurrentTrackResponse track = await spotifyService.GetCurrentlyPlayingTrack(token);
+            track = await spotifyService.GetCurrentlyPlayingTrack(token);
 
             //if token expired, refresh it
             if (track.ResponseMsg == System.Net.HttpStatusCode.Unauthorized)
             throw;
         }
 
+        //await identityService.SaveUserAsync(new GrpcShared.DTO.Db.UserResponse
+        //    {
+        //        Token = tokenS
+        //    });
+
+        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 = "630748c8d149033aaf5a774a"
+            });
 
+        //var resp = await identityService.ListUsersAsync(new VoidMessage());
 
+        //var tokenFromDb = await identityService.GetTokenByIdAsync(new GrpcShared.DTO.Db.DbRequestMessage
+        //    {
+        //        Id = "63074188426efd486fadd74d"
+        //    });
+
+        //var trackByUser = await identityService.GetTrackByUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
+        //    {
+        //        Id = "63074188426efd486fadd74d"
+        //    });
+        //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"
+        //    });
+        //find id from local storage
+            await identityService.DeleteUserAsync(new GrpcShared.DTO.Db.DbRequestMessage
+            {
+                Id = "630748c8d149033aaf5a774a"
+            });
     }
 }