hallo

Desktop/hallo/LEA/Controllers/AccountController.cs

@@ -0,0 +1,138 @@
+using System.Security.Claims;
+using LEA.Models;
+using LEA.ViewModels;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace LEA.Controllers;
+
+public class AccountController : Controller
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly SignInManager<ApplicationUser> _signInManager;
+    private readonly ILogger<AccountController> _logger;
+
+    public AccountController(
+        UserManager<ApplicationUser> userManager,
+        SignInManager<ApplicationUser> signInManager,
+        ILogger<AccountController> logger)
+    {
+        _userManager = userManager;
+        _signInManager = signInManager;
+        _logger = logger;
+    }
+
+    [HttpGet]
+    [AllowAnonymous]
+    public IActionResult Register()
+    {
+        return View(new RegisterViewModel());
+    }
+
+    [HttpPost]
+    [AllowAnonymous]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> Register(RegisterViewModel model)
+    {
+        if (!ModelState.IsValid)
+        {
+            return View(model);
+        }
+
+        var existingUser = await _userManager.FindByEmailAsync(model.Email);
+        if (existingUser != null)
+        {
+            ModelState.AddModelError(nameof(model.Email), "Diese E-Mail-Adresse wird bereits verwendet.");
+            return View(model);
+        }
+
+        var user = new ApplicationUser
+        {
+            FullName = model.FullName.Trim(),
+            Email = model.Email.Trim(),
+            UserName = model.Email.Trim(),
+            CreatedAt = DateTime.UtcNow
+        };
+
+        var result = await _userManager.CreateAsync(user, model.Password);
+        if (result.Succeeded)
+        {
+            await _userManager.AddClaimAsync(user, new Claim("FullName", user.FullName));
+            await _signInManager.SignInAsync(user, isPersistent: true);
+            _logger.LogInformation("Neuer Benutzer {Email} wurde erstellt und angemeldet.", user.Email);
+            TempData["Success"] = "Registrierung erfolgreich. Willkommen zurück!";
+            return RedirectToAction("Index", "Applications");
+        }
+
+        foreach (var error in result.Errors)
+        {
+            ModelState.AddModelError(string.Empty, TranslateIdentityError(error));
+        }
+
+        return View(model);
+    }
+
+    [HttpGet]
+    [AllowAnonymous]
+    public IActionResult Login(string? returnUrl = null)
+    {
+        return View(new LoginViewModel { ReturnUrl = returnUrl });
+    }
+
+    [HttpPost]
+    [AllowAnonymous]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> Login(LoginViewModel model)
+    {
+        if (!ModelState.IsValid)
+        {
+            return View(model);
+        }
+
+        var user = await _userManager.FindByEmailAsync(model.Email);
+        if (user == null)
+        {
+            ModelState.AddModelError(string.Empty, "Ungültige Anmeldedaten.");
+            return View(model);
+        }
+
+        var result = await _signInManager.PasswordSignInAsync(user, model.Password, model.RememberMe, lockoutOnFailure: false);
+        if (result.Succeeded)
+        {
+            _logger.LogInformation("Benutzer {Email} hat sich angemeldet.", user.Email);
+            if (!string.IsNullOrWhiteSpace(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl))
+            {
+                return Redirect(model.ReturnUrl);
+            }
+
+            TempData["Success"] = "Erfolgreich angemeldet.";
+            return RedirectToAction("Index", "Applications");
+        }
+
+        ModelState.AddModelError(string.Empty, "Ungültige Anmeldedaten.");
+        return View(model);
+    }
+
+    [HttpPost]
+    [Authorize]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> Logout()
+    {
+        await _signInManager.SignOutAsync();
+        TempData["Success"] = "Sie wurden abgemeldet.";
+        return RedirectToAction("Index", "Home");
+    }
+
+    private static string TranslateIdentityError(IdentityError error) => error.Code switch
+    {
+        "PasswordTooShort" => "Das Passwort ist zu kurz.",
+        "PasswordRequiresNonAlphanumeric" => "Das Passwort muss mindestens ein Sonderzeichen enthalten.",
+        "PasswordRequiresDigit" => "Das Passwort muss mindestens eine Zahl enthalten.",
+        "PasswordRequiresUpper" => "Das Passwort muss mindestens einen Großbuchstaben enthalten.",
+        "PasswordRequiresLower" => "Das Passwort muss mindestens einen Kleinbuchstaben enthalten.",
+        "DuplicateEmail" or "DuplicateUserName" => "Diese E-Mail-Adresse wird bereits verwendet.",
+        "InvalidEmail" => "Bitte eine gültige E-Mail-Adresse eingeben.",
+        _ => error.Description
+    };
+}