promiscuity/microservices/AuthApi/Services/UserService.cs

using AuthApi.Models;
using MongoDB.Bson;
using MongoDB.Driver;
using System.Text.RegularExpressions;

namespace AuthApi.Services;

public class UserService
{
    private readonly IMongoCollection<User> _col;

    public UserService(IConfiguration cfg)
    {
        var cs = cfg["MongoDB:ConnectionString"] ?? "mongodb://127.0.0.1:27017";
        var dbName = cfg["MongoDB:DatabaseName"] ?? "GameDb";
        var client = new MongoClient(cs);
        var db = client.GetDatabase(dbName);
        _col = db.GetCollection<User>("Users");

        var keys = Builders<User>.IndexKeys.Ascending(u => u.Username);
        _col.Indexes.CreateOne(new CreateIndexModel<User>(keys, new CreateIndexOptions { Unique = true }));
        var steamKeys = Builders<User>.IndexKeys.Ascending(u => u.SteamId);
        _col.Indexes.CreateOne(new CreateIndexModel<User>(steamKeys, new CreateIndexOptions<User>
        {
            Unique = true,
            PartialFilterExpression = new BsonDocument("SteamId", new BsonDocument("$type", "string"))
        }));
    }

    public async Task<User?> GetByUsernameAsync(string username) =>
        await _col.Find(u => u.Username == username).FirstOrDefaultAsync();

    public async Task<User?> GetByIdAsync(string id) =>
        await _col.Find(u => u.Id == id).FirstOrDefaultAsync();

    public async Task<User?> GetByEmailAsync(string email) =>
        await _col.Find(u => u.Email == email).FirstOrDefaultAsync();

    public async Task<List<User>> GetByLoginCandidatesAsync(string login)
    {
        var normalized = login.Trim();
        var usernameMatch = await GetByUsernameAsync(normalized);
        if (usernameMatch is not null)
            return [usernameMatch];
        var emailPattern = new BsonRegularExpression($"^{Regex.Escape(normalized)}$", "i");
        return await _col.Find(Builders<User>.Filter.Regex(u => u.Email, emailPattern)).ToListAsync();
    }

    public async Task<User?> GetBySteamIdAsync(string steamId) =>
        await _col.Find(u => u.SteamId == steamId).FirstOrDefaultAsync();

    public Task CreateAsync(User user) => _col.InsertOneAsync(user);

    public Task UpdateAsync(User user) =>
        _col.ReplaceOneAsync(u => u.Id == user.Id, user);

    public async Task<bool> TryLinkSteamAsync(string userId, string steamId, string refreshToken, DateTime refreshExpiry)
    {
        var filter = Builders<User>.Filter.Eq(u => u.Id, userId) &
            (Builders<User>.Filter.Eq(u => u.SteamId, null) | Builders<User>.Filter.Eq(u => u.SteamId, steamId));
        var update = Builders<User>.Update
            .Set(u => u.SteamId, steamId)
            .Set(u => u.RefreshToken, refreshToken)
            .Set(u => u.RefreshTokenExpiry, refreshExpiry);
        var result = await _col.UpdateOneAsync(filter, update);
        return result.MatchedCount == 1;
    }

    public Task DeleteAsync(string id) => _col.DeleteOneAsync(u => u.Id == id);

    public Task<List<User>> GetAllAsync() =>
        _col.Find(FilterDefinition<User>.Empty).ToListAsync();
}