Как получить Id вошедшего в систему пользователя

    public class LoginModel
    {
        public Guid Id { get; set; }
 
        [Required]
        public string Login { get; set; }
 
        [Required]
        [DataType(DataType.Password)]
        public string Password { get; set; }
 
        public string Nikename { get; set; }
 
    }
 
    public class RegisterModel
    {
        [Required]
        public string Login { get; set; }
 
        [Required]
        public string Nickname { get; set; }
 
        [Required]
        [DataType(DataType.Password)]
        public string Password { get; set; }
 
        [Required]
        [DataType(DataType.Password)]
        [Compare("Password", ErrorMessage = "Пароли не совпадают")]
        public string ConfirmPassword { get; set; }
 
        [Required]
        [DataType(DataType.EmailAddress)]
        public string Email { get; set; }
 
        public string Firstname { get; set; }
 
        public string Secondname { get; set; }
 
    }

        public class AccountController : Controller
    {
        private BlogsDBEntities db = new BlogsDBEntities();
 
        [HttpGet]
        public ActionResult Login()
        {
            return View();
        }
 
        [HttpPost]
        [ValidateAntiForgeryToken]
        [AllowAnonymous]
        public async Task<ActionResult> Login(LoginModel model)
        {
            if (ModelState.IsValid)
            {
                user User = null;
                User = await db.users.FirstOrDefaultAsync(u => u.login == model.Login);
                
                if (User != null)
                {
                    var salt = User.salt;
                    var saltedPassword = model.Password + salt;
                    var hashedPassword = Crypto.HashPassword(saltedPassword);
 
                    if (Crypto.VerifyHashedPassword(hashedPassword, saltedPassword))
                    {
                        User.last_login = DateTime.Now;
                        db.Entry(User).State = System.Data.Entity.EntityState.Modified;
                        await db.SaveChangesAsync();
                        model.Nikename = User.nickname;
                        model.Id = User.Id;
                        FormsAuthentication.SetAuthCookie(model.Nikename, true);
                        
                        return RedirectToAction("Index", "Home", model.Id);
                    }
                }
                else
                {
                    ModelState.AddModelError("", "Неверное имя пользователя или пароль.");
                }
            }
            return View(model);
        }
 
        [HttpGet]
        public ActionResult Register()
        {
            return View();
        }
 
        [HttpPost]
        [ValidateAntiForgeryToken]
        [AllowAnonymous]
        public async Task<ActionResult> Register(RegisterModel model)
        {
            if (ModelState.IsValid)
            {
                user UserC = null;
                UserC = await db.users.FirstOrDefaultAsync(u => u.login == model.Login || u.email == model.Email);
 
                if (UserC == null)
                {
                    var salt = Crypto.GenerateSalt();
                    var saltedPassword = model.Password + salt;
                    var hashedPassword = Crypto.HashPassword(saltedPassword);
                    db.users.Add(new user { Id = Guid.NewGuid(),
                                            login = model.Login,
                                            nickname = model.Nickname,
                                            hashPassword = hashedPassword,
                                            salt = salt,
                                            email = model.Email,
                                            firstname = model.Firstname,
                                            secondname = model.Secondname,
                                            reg_date = DateTime.Now,
                                            last_login = DateTime.Now,
                                            user_url = model.Login });
                    await db.SaveChangesAsync();
 
                    UserC = await db.users.Where(u => u.login == model.Login).FirstOrDefaultAsync();
 
                    if (UserC != null)
                    {
                        FormsAuthentication.SetAuthCookie(model.Login, true);
                        return RedirectToAction("Index", "Home");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "Логин или E-mail уже используютсья.");
                }
            }
 
            return View(model);
        }
 
        public ActionResult Logoff()
        {
            FormsAuthentication.SignOut();
            return RedirectToAction("Index", "Home");
        }
 
        public async Task<ActionResult> Details()
        {
            var id = User.Identity.GetUserId();
 
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
 
            user UserC = null;
            UserC = await db.users.FindAsync(id);
 
            if (UserC == null)
            {
                return HttpNotFound();
            }
 
            return View(UserC);
        }
    }
}

        private const string cookieName = "auth_cookies";
 
        private void CreateCookie(string userName, string userData, bool isPersistent = false)
        {
            var ticket = new FormsAuthenticationTicket(
                  1,
                  userName,
                  DateTime.Now,
                  DateTime.Now.Add(FormsAuthentication.Timeout),
                  isPersistent,
                  userData,
                  FormsAuthentication.FormsCookiePath);
 
            // Encrypt the ticket.
            var encTicket = FormsAuthentication.Encrypt(ticket);
 
            // Create the cookie.
            var AuthCookie = new HttpCookie(cookieName, encTicket);
            AuthCookie.Expires = DateTime.Now.Add(FormsAuthentication.Timeout);
 
            HttpContext.Response.Cookies.Set(AuthCookie);
        }

         public async Task<ActionResult> Login(LoginModel model)
        {
            if (ModelState.IsValid)
            {
                user User = null;
                User = await db.users.FirstOrDefaultAsync(u => u.login == model.Login);
                
                if (User != null)
                {
                    var salt = User.salt;
                    var saltedPassword = model.Password + salt;
                    var hashedPassword = Crypto.HashPassword(saltedPassword);
 
                    if (Crypto.VerifyHashedPassword(hashedPassword, saltedPassword))
                    {
                        User.last_login = DateTime.Now;
                        db.Entry(User).State = System.Data.Entity.EntityState.Modified;
                        await db.SaveChangesAsync();
                        
                        CreateCookie(User.login, User.Id.ToString());  //добавил эту строку
                        FormsAuthentication.SetAuthCookie(User.nickname, true);
 
                        return RedirectToAction("Index", "Home");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "Неверное имя пользователя или пароль.");
                }
            }
            return View(model);
        }
 
        [HttpPost]
        [ValidateAntiForgeryToken]
        [AllowAnonymous]
        public async Task<ActionResult> Register(RegisterModel model)
        {
            if (ModelState.IsValid)
            {
                user User = null;
                User = await db.users.FirstOrDefaultAsync(u => u.login == model.Login || u.email == model.Email);
 
                if (User == null)
                {
                    var salt = Crypto.GenerateSalt();
                    var saltedPassword = model.Password + salt;
                    var hashedPassword = Crypto.HashPassword(saltedPassword);
                    db.users.Add(new user { Id = Guid.NewGuid(),
                                            login = model.Login,
                                            nickname = model.Nickname,
                                            hashPassword = hashedPassword,
                                            salt = salt,
                                            email = model.Email,
                                            firstname = model.Firstname,
                                            secondname = model.Secondname,
                                            reg_date = DateTime.Now,
                                            last_login = DateTime.Now,
                                            user_url = model.Login });
                    await db.SaveChangesAsync();
 
                    User = await db.users.Where(u => u.login == model.Login).FirstOrDefaultAsync();
 
                    if (User != null)
                    {
                        CreateCookie(User.login, User.Id.ToString());  //добавил эту строку
                        FormsAuthentication.SetAuthCookie(model.Login, true);
                        return RedirectToAction("Index", "Home");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "Логин или E-mail уже используютсья.");
                }
            }
 
            return View(model);
        }

        public async Task<ActionResult> Details()
        {
            var cookie = Request.Cookies.Get(cookieName);
 
            if (cookie == null || cookie.Value == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
 
            var ticket = FormsAuthentication.Decrypt(cookie.Value);
 
            user User = null;
            User = await db.users.FindAsync(Guid.Parse(ticket.UserData));
 
            if (User == null)
            {
                return HttpNotFound();
            }
 
            return View(User);
        }

        public ActionResult Logoff()
        {
            var cookie = Request.Cookies.Get(cookieName);
 
            if (cookie != null)
            {
                cookie = null;
            }
 
            FormsAuthentication.SignOut();
            return RedirectToAction("Index", "Home");
        }