public async Task<IdentityResult> ChangeUserRolesAsync(ApplicationUser user, AccountRolesViewModel model) {
            IdentityResult result = null;
            try {
                logger.Info("Start");
                logger.Info("User Id: {0}", user.Id);
                logger.Debug("Change UserName from {0} to {1}", user.UserName, model.User.UserName);
                user.UserName = model.User.UserName;
                logger.Debug("Change PhoneNumber from {0} to {1}", user.PhoneNumber, model.User.PhoneNumber);
                user.PhoneNumber = model.User.PhoneNumber;
                logger.Debug("Change Email from {0} to {1}", user.Email, model.User.Email);
                user.Email = model.User.Email;

                result = await userManager.UpdateAsync(user);
                logger.Debug("Update result: {0}", result.Succeeded);
                if (result.Succeeded) {
                    foreach (var role in await userManager.GetRolesAsync(user.Id)) {
                        logger.Debug("User role: {0}", role);
                        result = await userManager.RemoveFromRoleAsync(user.Id, role);
                        logger.Debug("RemoveFromRole result: {0}", result.Succeeded);
                        if (!result.Succeeded)
                            return result;
                    }

                    result = await userManager.AddToRolesAsync(user.Id, model.Roles.Where(x => x.Checked).Select(x => x.Name).ToArray());
                    logger.Debug("AddToRoles result: {0}", result.Succeeded);
                }

                logger.Debug("return result: {0}", result.Succeeded);
                return result;
            }
            catch (Exception ex) {
                logger.Error(ex, ex.Message);
                throw;
            }
        }
        public async Task<AccountRolesViewModel> GetUserRolesAsync(ApplicationUser user) {
            try {
                logger.Info("Start");
                var accountRoles = new List<AccountRolesViewModel.AccountRole>();
                foreach (ApplicationRole role in await roleManager.Roles.ToListAsync()) {
                    accountRoles.Add(new AccountRolesViewModel.AccountRole {
                        Name = role.Name,
                        Description = role.Description,
                        Checked = await userManager.IsInRoleAsync(user.Id, role.Name)
                    });
                }

                logger.Info("End");
                return new AccountRolesViewModel {
                    User = user,
                    Roles = accountRoles
                };
            }
            catch (Exception ex) {
                logger.Error(ex, ex.Message);
                throw;
            }
        }
        public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) {
            if (User.Identity.IsAuthenticated) {
                return RedirectToAction("Index", "Manage");
            }

            if (ModelState.IsValid) {
                // Получение сведений о пользователе от внешнего поставщика входа
                var info = await AuthenticationManager.GetExternalLoginInfoAsync();
                if (info == null) {
                    return View("ExternalLoginFailure");
                }
                var user = new ApplicationUser { UserName = model.Name ?? model.Email, Email = model.Email };
                var result = await UserManager.CreateAsync(user);
                if (result.Succeeded) {
                    result = await UserManager.AddLoginAsync(user.Id, info.Login);
                    if (result.Succeeded) {
                        await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                        return RedirectToLocal(returnUrl);
                    }
                }

                AddErrors(result);
            }

            ViewBag.ReturnUrl = returnUrl;
            return View(model);
        }
        public async Task<ActionResult> Register(RegisterViewModel model) {
            if (ModelState.IsValid) {
                var user = new ApplicationUser { UserName = model.UserName, Email = model.Email };
                var result = await UserManager.CreateAsync(user, model.Password);
                if (result.Succeeded) {
                    //await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);

                    // Дополнительные сведения о том, как включить подтверждение учетной записи и сброс пароля, см. по адресу: http://go.microsoft.com/fwlink/?LinkID=320771
                    // Отправка сообщения электронной почты с этой ссылкой
                    // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                    // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    // await UserManager.SendEmailAsync(user.Id, "Подтверждение учетной записи", "Подтвердите вашу учетную запись, щелкнув <a href=\"" + callbackUrl + "\">здесь</a>");

                    return RedirectToAction("Index", "Home");
                }
                AddErrors(result);
            }

            // Появление этого сообщения означает наличие ошибки; повторное отображение формы
            return View(model);
        }
        public async Task<ActionResult> Delete(ApplicationUser appUser) {
            if (appUser.Id == null) {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }

            var user = await UserManager.FindByIdAsync(appUser.Id);
            if (user == null) {
                return HttpNotFound();
            }

            var result = await UserManager.DeleteAsync(user);
            logger.Debug("Delete user: {0}", result.Succeeded);

            return RedirectToAction("Index");
        }