context: //-----------------------------------------------------------------------
  // <copyright file="AccountController.cs" company="AccountGo">
  // Copyright (c) AccountGo. All rights reserved.
  // <author>Marvin Perez</author>
  // <date>1/11/2015 9:48:38 AM</date>
  // </copyright>
  //-----------------------------------------------------------------------
  
  using System.Linq;
  using System.Threading.Tasks;
  using System.Web;
  using System.Web.Mvc;
  using Microsoft.AspNet.Identity;
  using Microsoft.AspNet.Identity.Owin;
  using Microsoft.Owin.Security;
  using Web.Models;
  using Services.Security;
  
  namespace Web.Controllers
  {
      [Authorize]
      public class AccountController : Controller
      {
          private ApplicationSignInManager _signInManager;
          private ApplicationUserManager _userManager;
          private ISecurityService _securityService;
          private readonly Services.Administration.IAdministrationService _administrationService;
          public AccountController(ISecurityService securityService, Services.Administration.IAdministrationService administrationService)
          {
              _securityService = securityService;
              _administrationService = administrationService;
          }
          public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, ISecurityService securityService)
          {
              UserManager = userManager;
              SignInManager = signInManager;
              _securityService = securityService;
          }
  
          public ApplicationSignInManager SignInManager
          {
              get
              {
                  return _signInManager ?? HttpContext.GetOwinContext().Get<ApplicationSignInManager>();
              }
              private set 
              { 
                  _signInManager = value; 
              }
          }
  
          public ApplicationUserManager UserManager
          {
              get
              {
                  return _userManager ?? HttpContext.GetOwinContext().GetUserManager<ApplicationUserManager>();
              }
              private set
              {
                  _userManager = value;
              }
          }
  
          //
          // GET: /Account/Login
          [AllowAnonymous]
          public ActionResult Login(string returnUrl)
          {
              ViewBag.ReturnUrl = returnUrl;
              return View();
          }
  
          //
          // POST: /Account/Login
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
          {
              if (_administrationService.GetDefaultCompany() == null)
                  Data.DbInitializerHelper.Initialize();
              return View(model);
              //if (!ModelState.IsValid)
              //{
              //    return View(model);
              //}
  
              //// This doesn't count login failures towards account lockout
              //// To enable password failures to trigger account lockout, change to shouldLockout: true
              //var result = await SignInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, shouldLockout: false);
              //if(result == SignInStatus.Failure && model.Username == "admin")
              //{
              //    var user = new ApplicationUser { UserName = model.Username, Email = "admin@email.com" };
              //    var res = await UserManager.CreateAsync(user, model.Password);
              //    if (res.Succeeded)
              //    {
              //        await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
  
              //        // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
              //        // Send an email with this link
              //        // 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, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
              //        _securityService.AddUser(user.UserName, user.Email, string.Empty, string.Empty);
              //        return RedirectToAction("Index", "Home");
              //    }
              //}
              //switch (result)
              //{
              //    case SignInStatus.Success:
              //        return RedirectToLocal(returnUrl);
              //    case SignInStatus.LockedOut:
              //        return View("Lockout");
              //    case SignInStatus.RequiresVerification:
              //        return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
              //    case SignInStatus.Failure:
              //    default:
              //        ModelState.AddModelError("", "Invalid login attempt.");
              //        return View(model);
              //}
          }
  
          //
          // GET: /Account/VerifyCode
          [AllowAnonymous]
          public async Task<ActionResult> VerifyCode(string provider, string returnUrl, bool rememberMe)
          {
              // Require that the user has already logged in via username/password or external login
              if (!await SignInManager.HasBeenVerifiedAsync())
              {
                  return View("Error");
              }
              return View(new VerifyCodeViewModel { Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe });
          }
  
          //
          // POST: /Account/VerifyCode
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> VerifyCode(VerifyCodeViewModel model)
          {
              if (!ModelState.IsValid)
              {
                  return View(model);
              }
  
              // The following code protects for brute force attacks against the two factor codes. 
              // If a user enters incorrect codes for a specified amount of time then the user account 
              // will be locked out for a specified amount of time. 
              // You can configure the account lockout settings in IdentityConfig
              var result = await SignInManager.TwoFactorSignInAsync(model.Provider, model.Code, isPersistent:  model.RememberMe, rememberBrowser: model.RememberBrowser);
              switch (result)
              {
                  case SignInStatus.Success:
                      return RedirectToLocal(model.ReturnUrl);
                  case SignInStatus.LockedOut:
                      return View("Lockout");
                  case SignInStatus.Failure:
                  default:
                      ModelState.AddModelError("", "Invalid code.");
                      return View(model);
              }
          }
  
          //
          // GET: /Account/Register
          [AllowAnonymous]
          public ActionResult Register()
          {
              return View();
          }
  
          //
          // POST: /Account/Register
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          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);
  
                      // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                      // Send an email with this link
                      // 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, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
                      _securityService.AddUser(user.UserName, user.Email, string.Empty, string.Empty);
                      return RedirectToAction("Index", "Home");
                  }
                  AddErrors(result);
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/ConfirmEmail
          [AllowAnonymous]
          public async Task<ActionResult> ConfirmEmail(string userId, string code)
          {
              if (userId == null || code == null)
              {
                  return View("Error");
              }
              var result = await UserManager.ConfirmEmailAsync(userId, code);
              return View(result.Succeeded ? "ConfirmEmail" : "Error");
          }
  
          //
          // GET: /Account/ForgotPassword
          [AllowAnonymous]
          public ActionResult ForgotPassword()
          {
              return View();
          }
  
          //
          // POST: /Account/ForgotPassword
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> ForgotPassword(ForgotPasswordViewModel model)
          {
              if (ModelState.IsValid)
              {
                  var user = await UserManager.FindByNameAsync(model.Email);
                  if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id)))
                  {
                      // Don't reveal that the user does not exist or is not confirmed
                      return View("ForgotPasswordConfirmation");
                  }
  
                  // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                  // Send an email with this link
                  // string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
                  // var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);		
                  // await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
                  // return RedirectToAction("ForgotPasswordConfirmation", "Account");
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/ForgotPasswordConfirmation
          [AllowAnonymous]
          public ActionResult ForgotPasswordConfirmation()
          {
              return View();
          }
  
          //
          // GET: /Account/ResetPassword
          [AllowAnonymous]
          public ActionResult ResetPassword(string code)
          {
              return code == null ? View("Error") : View();
          }
  
          //
          // POST: /Account/ResetPassword
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
          {
              if (!ModelState.IsValid)
              {
                  return View(model);
              }
              var user = await UserManager.FindByNameAsync(model.Email);
              if (user == null)
              {
                  // Don't reveal that the user does not exist
                  return RedirectToAction("ResetPasswordConfirmation", "Account");
              }
              var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
              if (result.Succeeded)
              {
                  return RedirectToAction("ResetPasswordConfirmation", "Account");
              }
              AddErrors(result);
              return View();
          }
  
          //
          // GET: /Account/ResetPasswordConfirmation
          [AllowAnonymous]
          public ActionResult ResetPasswordConfirmation()
          {
              return View();
          }
  
          //
          // POST: /Account/ExternalLogin
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public ActionResult ExternalLogin(string provider, string returnUrl)
          {
              // Request a redirect to the external login provider
              return new ChallengeResult(provider, Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl }));
          }
  
          //
          // GET: /Account/SendCode
          [AllowAnonymous]
          public async Task<ActionResult> SendCode(string returnUrl, bool rememberMe)
          {
              var userId = await SignInManager.GetVerifiedUserIdAsync();
              if (userId == null)
              {
                  return View("Error");
              }
              var userFactors = await UserManager.GetValidTwoFactorProvidersAsync(userId);
              var factorOptions = userFactors.Select(purpose => new SelectListItem { Text = purpose, Value = purpose }).ToList();
              return View(new SendCodeViewModel { Providers = factorOptions, ReturnUrl = returnUrl, RememberMe = rememberMe });
          }
  
          //
          // POST: /Account/SendCode
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> SendCode(SendCodeViewModel model)
          {
              if (!ModelState.IsValid)
              {
                  return View();
              }
  
              // Generate the token and send it
              if (!await SignInManager.SendTwoFactorCodeAsync(model.SelectedProvider))
              {
                  return View("Error");
              }
              return RedirectToAction("VerifyCode", new { Provider = model.SelectedProvider, ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe });
          }
  
          //
          // GET: /Account/ExternalLoginCallback
          [AllowAnonymous]
          public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
          {
              var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
              if (loginInfo == null)
              {
                  return RedirectToAction("Login");
              }
  
              // Sign in the user with this external login provider if the user already has a login
              var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
              switch (result)
              {
                  case SignInStatus.Success:
                      return RedirectToLocal(returnUrl);
                  case SignInStatus.LockedOut:
                      return View("Lockout");
                  case SignInStatus.RequiresVerification:
                      return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = false });
                  case SignInStatus.Failure:
                  default:
                      // If the user does not have an account, then prompt the user to create an account
                      ViewBag.ReturnUrl = returnUrl;
                      ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
                      return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
              }
          }
  
          //
          // POST: /Account/ExternalLoginConfirmation
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
          {
              if (User.Identity.IsAuthenticated)
              {
                  return RedirectToAction("Index", "Manage");
              }
  
              if (ModelState.IsValid)
              {
                  // Get the information about the user from the external login provider
                  var info = await AuthenticationManager.GetExternalLoginInfoAsync();
                  if (info == null)
                  {
                      return View("ExternalLoginFailure");
                  }
                  var user = new ApplicationUser { UserName = 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);
          }
  
          //
          // POST: /Account/LogOff
          [HttpPost]
          [ValidateAntiForgeryToken]
          public ActionResult LogOff()
          {
              AuthenticationManager.SignOut();
              return RedirectToAction("Index", "Home");
          }
  
          //
          // GET: /Account/ExternalLoginFailure
          [AllowAnonymous]
          public ActionResult ExternalLoginFailure()
          {
              return View();
          }
  
          protected override void Dispose(bool disposing)
          {
              if (disposing)
              {
  
gt:                 if (_userManager != null)