NemAn/IdentityProvider/Services/IdentityService.cs

using GrpcShared.DTO;
using GrpcShared.DTO.Db;
using GrpcShared.Interfaces;
using IdentityProvider.Models;
using Microsoft.Extensions.Options;
using MongoDB.Driver;

namespace IdentityProvider.Services
{
    public class IdentityService : IIdentityService
    {
        private readonly IMongoCollection<UserModel> _userCollection;
        private readonly IMongoCollection<TrackModel> _trackCollection;
        public IdentityService(IOptions<SpotifyDbConfig> spotifyDbConfig)
        {
            var mongoClient = new MongoClient(spotifyDbConfig.Value.ConnString);
            var mongoDbContext = mongoClient.GetDatabase(spotifyDbConfig.Value.DBName);
            _userCollection = mongoDbContext.GetCollection<UserModel>(spotifyDbConfig.Value.UserCollection);
            _trackCollection = mongoDbContext.GetCollection<TrackModel>(spotifyDbConfig.Value.TrackCollection);
        }


        public async Task<List<UserResponse>> ListUsersAsync(VoidMessage msg)
        {
            List<UserModel> users = await _userCollection.Find(_ => true).ToListAsync();
            //map users to match the grpc response
            return users.Select(u => new UserResponse
            {
                Id = u.Id,
                Token = u.Token
            }).ToList();
        }
        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
            };
        }
        public async Task<TrackResponse> GetTrackByUserAsync(DbRequestMessage request)
        {
            TrackModel track = await _trackCollection.Find(t => t.UserId == request.Id).FirstOrDefaultAsync();
            return new TrackResponse
            {
                Id = track.Id,
                Album = track.Album,
                Artist = track.Artist,
                Title = track.Title
            };
        }
        public async Task<VoidMessage> SaveTrackAsync(SaveTrackRequest track)
        {

            TrackModel trackModel = new()
            {
                Title = track.Title,
                Album = track.Album,
                Artist = track.Artist,
                UserId = track.UserId
            };
            //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);

            if (song != null) await _trackCollection.ReplaceOneAsync(x => x.UserId == track.UserId, trackModel);

            else await _trackCollection.InsertOneAsync(trackModel);

            return new VoidMessage();


        }
        public async Task<VoidMessage> SaveUserAsync(UserResponse user)
        {
            await _userCollection.InsertOneAsync(new UserModel
            {
                Id = user.Id,
                Token = user.Token
            });
            return new VoidMessage();
        }
        public async Task<VoidMessage> DeleteTrackAsync(DbRequestMessage request)
        {
            await _trackCollection.DeleteOneAsync(x => x.Id == request.Id);
            return new VoidMessage();
        }
        public async Task<VoidMessage> DeleteUserAsync(DbRequestMessage user)
        {
            await _userCollection.DeleteOneAsync(x => x.Id == user.Id);
            return new VoidMessage();
        }



    }
}