Форма логина на AngularJS с ASP.NET, часть 1

public class AccountController : Controller
{
    [HttpPost]
    public ActionResult VerifyUser(UserModel model)
    {
        // Валидация и аутентификация
        var user = _userService.Authenticate(model.Email, model.Password);
        
        return new JsonResult
        {
            Data = user,
            JsonRequestBehavior = JsonRequestBehavior.AllowGet
        };
    }
}

public ActionResult VerifyUser(UserModel obj)
{
    DatabaseEntities db = new DatabaseEntities();
    var user = db.Users.Where(x => x.Email.Equals(obj.Email) && x.Password.Equals(obj.Password)).FirstOrDefault();
    return new JsonResult {
        Data = user,
        JsonRequestBehavior = JsonRequestBehavior.AllowGet
    };
}

[HttpPost]
[Route("api/auth/token")]
public ActionResult CreateToken([FromBody] LoginModel model)
{
    // Логика аутентификации
}
 
[HttpDelete]
[Route("api/auth/session")]
public ActionResult DestroySession()
{
    // Логика выхода
}

[RoutePrefix("api/auth")]
public class AuthController : ApiController
{
    [HttpPost]
    [Route("token")]
    public IHttpActionResult GetToken(LoginModel model)
    {
        // Логика аутентификации
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
            
        var user = _userService.Authenticate(model.Username, model.Password);
        if (user == null)
            return Unauthorized();
            
        var token = _tokenService.GenerateToken(user);
        return Ok(new { token = token });
    }
    
    [HttpDelete]
    [Route("session")]
    [Authorize]
    public IHttpActionResult Logout()
    {
        // Логика выхода
        _tokenService.InvalidateToken(User.Identity.Name);
        return Ok();
    }
}

namespace LoginUsingAngular.Models
{
    public class UserModel
    {
        [Required(ErrorMessage = "Email не может быть пустым")]
        [EmailAddress(ErrorMessage = "Некорректный формат email")]
        public string Email { get; set; }
        
        [Required(ErrorMessage = "Пароль не может быть пустым")]
        [MinLength(8, ErrorMessage = "Пароль должен содержать минимум 8 символов")]
        public string Password { get; set; }
    }
}

[Required(ErrorMessage = "Пароль не может быть пустым")]
[MinLength(8, ErrorMessage = "Пароль должен содержать минимум 8 символов")]
[RegularExpression(@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).{8,}$", 
    ErrorMessage = "Пароль должен содержать заглавные и строчные буквы, цифры и специальные символы")]
public string Password { get; set; }

public class AccountController : Controller
{
    private readonly IUserService _userService;
    private readonly ILogger<AccountController> _logger;
    
    public AccountController(IUserService userService, ILogger<AccountController> logger)
    {
        _userService = userService;
        _logger = logger;
    }
    
    [HttpPost]
    [Route("api/auth/login")]
    public async Task<IActionResult> Login([FromBody] UserModel model)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        try 
        {
            var result = await _userService.AuthenticateAsync(model.Email, model.Password);
            
            if (result == null)
            {
                // Важно: не раскрываем, что именно неверно - логин или пароль
                _logger.LogWarning($"Неудачная попытка входа для {model.Email}");
                return Unauthorized(new { message = "Неверный email или пароль" });
            }
            
            // Создаем токен или устанавливаем куки
            var token = GenerateJwtToken(result);
            
            return Ok(new { token = token, userName = result.FullName });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"Ошибка при авторизации пользователя {model.Email}");
            return StatusCode(500, new { message = "Внутренняя ошибка сервера" });
        }
    }
    
    // Другие методы для регистрации, выхода и т.д.
}

public class PasswordHistoryValidator : ValidationAttribute
{
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var userService = (IUserService)validationContext.GetService(typeof(IUserService));
        var userModel = (UserModel)validationContext.ObjectInstance;
        
        if (userService.IsPasswordInHistory(userModel.Email, (string)value))
        {
            return new ValidationResult("Этот пароль уже использовался ранее. Выберите другой пароль.");
        }
        
        return ValidationResult.Success;
    }
}

public interface IUserValidationService
{
    Task<ValidationResult> ValidateCredentialsAsync(string email, string password);
    Task<ValidationResult> ValidateNewPasswordAsync(string email, string newPassword);
}

if (_userService.GetFailedLoginAttempts(model.Email) >= 5)
{
    _logger.LogWarning($"Превышено количество попыток входа для {model.Email}");
    return StatusCode(429, new { message = "Слишком много попыток входа. Аккаунт временно заблокирован." });
}

if (result == null)
{
    await Task.Delay(TimeSpan.FromSeconds(1)); // Замедляем ответ
    return Unauthorized(new { message = "Неверный email или пароль" });
}

// Плохо:
return Ok(new { 
    token = token, 
    user = new { 
        id = result.Id, 
        email = result.Email,
        isAdmin = result.IsAdmin,
        lastLoginIp = result.LastLoginIp
    }
});
 
// Хорошо:
return Ok(new { 
    token = token, 
    user = new { 
        displayName = result.DisplayName
    }
});

public enum AuthResultStatus
{
    Success,
    InvalidCredentials,
    Locked,
    RequiresPasswordChange,
    Requires2FA,
    Expired
}
 
public class AuthResult
{
    public AuthResultStatus Status { get; set; }
    public UserDTO User { get; set; }
    public string Token { get; set; }
    public string Message { get; set; }
}

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<User> Users { get; set; }
    public DbSet<UserRole> UserRoles { get; set; }
    public DbSet<LoginAttempt> LoginAttempts { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Уникальный индекс для email
        modelBuilder.Entity<User>()
            .HasIndex(u => u.Email)
            .IsUnique();
            
        // Составной ключ для связи пользователь-роль
        modelBuilder.Entity<UserRole>()
            .HasKey(ur => new { ur.UserId, ur.RoleId });
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
            
    // Другие сервисы
}

public class User
{
    public int Id { get; set; }
    
    [Required]
    [MaxLength(100)]
    public string Email { get; set; }
    
    [Required]
    public string PasswordHash { get; set; }
    
    public string PasswordSalt { get; set; }
    
    [MaxLength(100)]
    public string FullName { get; set; }
    
    public bool IsActive { get; set; } = true;
    
    public DateTime LastLoginDate { get; set; }
    
    public string LastLoginIp { get; set; }
    
    public int FailedLoginAttempts { get; set; }
    
    public DateTime? LockoutEndDate { get; set; }
    
    // Навигационные свойства
    public virtual ICollection<UserRole> UserRoles { get; set; }
    public virtual ICollection<LoginAttempt> LoginAttempts { get; set; }
}

public interface IUserRepository
{
    Task<User> GetByEmailAsync(string email);
    Task<bool> ExistsAsync(string email);
    Task<User> CreateAsync(User user);
    Task UpdateAsync(User user);
    Task IncrementFailedLoginAttemptsAsync(string email);
    Task ResetFailedLoginAttemptsAsync(string email);
    Task<int> GetFailedLoginAttemptsAsync(string email);
    Task LockoutAsync(string email, TimeSpan duration);
    Task LogLoginAttemptAsync(string email, string ipAddress, bool succeeded);
}
 
public class UserRepository : IUserRepository
{
    private readonly ApplicationDbContext _context;
    
    public UserRepository(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<User> GetByEmailAsync(string email)
    {
        return await _context.Users
            .Include(u => u.UserRoles)
            .FirstOrDefaultAsync(u => u.Email == email);
    }
    
    // Реализация остальных методов...
}

modelBuilder.Entity<User>()
    .HasIndex(u => u.Email);

var user = await _context.Users
    .Select(u => new { u.Id, u.Email, u.PasswordHash, u.PasswordSalt, u.IsActive })
    .FirstOrDefaultAsync(u => u.Email == email);

// Плохо - блокирующий вызов
var user = _context.Users.FirstOrDefault(u => u.Email == email);
 
// Хорошо - асинхронный вызов
var user = await _context.Users.FirstOrDefaultAsync(u => u.Email == email);