was added new rules to usernames

Govor.Application/Infrastructure/AdminsStuff/UsersService.cs

@@ -1,4 +1,5 @@
 using Govor.Application.Interfaces;
+using Govor.Core.Infrastructure.Extensions;
 using Govor.Core.Models.Users;
 using Govor.Core.Repositories.Users;
 using Govor.Data.Repositories.Exceptions;
@@ -8,10 +9,12 @@ namespace Govor.Application.Infrastructure.AdminsStuff;
 public class UsersService : IUsersAdministration
 {
     private readonly IUsersRepository _usersRepository;
-
-    public UsersService(IUsersRepository usersRepository)
+    private readonly IPasswordHasher _passwordHasher;
+    
+    public UsersService(IUsersRepository usersRepository, IPasswordHasher passwordHasher)
     {
         _usersRepository = usersRepository;
+        _passwordHasher = passwordHasher;
     }
 
     public async Task<List<User>> GetAllUsersAsync()
@@ -27,6 +30,22 @@ public class UsersService : IUsersAdministration
         }
     }
 
+    public async Task SetPasswordAsync(Guid userId, string password)
+    {
+        try
+        {
+            var user = await _usersRepository.FindByIdAsync(userId);
+            
+            user.PasswordHash = _passwordHasher.Hash(password);
+            
+            await _usersRepository.UpdateAsync(user);
+        }
+        catch (NotFoundException ex)
+        {
+            throw new NotFoundException(ex.Message);
+        }
+    }
+    
     public async Task<User> GetUserById(Guid userId)
     {
         var result = await _usersRepository.FindByIdAsync(userId);

Govor.Application/Infrastructure/Validators/UsernameValidator.cs

@@ -2,6 +2,7 @@ using System.Text.RegularExpressions;
 using Govor.Application.Exceptions.AuthService;
 using Govor.Application.Interfaces.Authentication;
 using Govor.Core.Infrastructure.Validators;
+using Microsoft.Extensions.Configuration;
 
 namespace Govor.Application.Infrastructure.Validators;
 
@@ -9,6 +10,33 @@ public class UsernameValidator : IUsernameValidator
 {
     private readonly Regex _usernameRegex = new(@"^[А-Яа-яЁё]+[А-Яа-яЁё0-9]*$", RegexOptions.Compiled);
     
+    private readonly HashSet<string> _blockedExact;
+    private readonly List<string> _blockedContains;
+    private readonly HashSet<string> _reserved;
+
+    public UsernameValidator(IConfiguration config)
+    {
+        _blockedExact = config.GetSection("UsernameModeration:BlockedExact")
+                            .Get<string[]>()?
+                            .Select(Normalize)
+                            .ToHashSet()
+                        ?? throw new InvalidOperationException("BlockedExact not set");
+
+        _blockedContains = config
+                               .GetSection("UsernameModeration:BlockedContains")
+                               .Get<string[]>()?
+                               .Select(Normalize)
+                               .ToList()
+                           ?? throw new InvalidOperationException("BlockedContains not set");
+
+        _reserved = config
+                        .GetSection("UsernameModeration:Reserved")
+                        .Get<string[]>()?
+                        .Select(Normalize)
+                        .ToHashSet()
+                    ?? throw new InvalidOperationException("Reserved not set");
+    }
+    
     public void Validate(string username)
     {
         if(username.Length < UserValidator.MIN_LENGHT_OF_NAME || username.Length > UserValidator.MAX_LENGHT_OF_NAME)
@@ -16,6 +44,23 @@ public class UsernameValidator : IUsernameValidator
 
         if (!_usernameRegex.IsMatch(username))
             throw new InvalidUsernameException("The username must be in Cyrillic and start with a letter.");
+        
+        if (Regex.IsMatch(username, @"(.)\1{4,}"))
+            throw new InvalidUsernameException("Too many repeating characters.");
+        
+        var normalized = Normalize(username);
+
+        if (_reserved.Contains(normalized))
+            throw new InvalidUsernameException("This username is reserved.");
+
+        if (_blockedExact.Contains(normalized))
+            throw new InvalidUsernameException("This username is not allowed.");
+
+        foreach (var banned in _blockedContains)
+        {
+            if (normalized.Contains(banned))
+                throw new InvalidUsernameException("Username contains prohibited content.");
+        }
     }
 
     public bool TryValidate(string username)
@@ -30,5 +75,16 @@ public class UsernameValidator : IUsernameValidator
             return false;
         }
     }
-
+        
+    private static string Normalize(string username)
+    {
+        return username
+            .ToLower()
+            .Replace("0", "о")
+            .Replace("1", "и")
+            .Replace("3", "е")
+            .Replace("4", "а")
+            .Replace("6", "б")
+            .Replace("8", "в");
+    }
 }