public async Task Add_Should_Add_New_Login_Just_After_UserManager_CreateAsync_Get_Called()
{
const string userName = "******";
const string loginProvider = "Twitter";
const string providerKey = "12345678";
using (IDocumentStore store = CreateEmbeddableStore())
{
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUserStore<RavenUser> userStore = new RavenUserStore<RavenUser>(ses);
UserManager<RavenUser> userManager = new UserManager<RavenUser>(userStore);
RavenUser user = new RavenUser(userName);
UserLoginInfo loginToAdd = new UserLoginInfo(loginProvider, providerKey);
await userManager.CreateAsync(user);
await userManager.AddLoginAsync(user.Id, loginToAdd);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
IUserLoginStore<RavenUser, string> userLoginStore = new RavenUserStore<RavenUser>(ses);
RavenUser user = await ses.LoadAsync<RavenUser>(RavenUser.GenerateKey(userName));
RavenUserLogin foundLogin = await ses.LoadAsync<RavenUserLogin>(RavenUserLogin.GenerateKey(loginProvider, providerKey));
// Assert
Assert.Equal(1, user.Logins.Count());
Assert.NotNull(foundLogin);
}
}
}
public async Task AddDuplicateLoginFailsTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var mgr = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var user = new IdentityUser("dupeLogintest");
UnitTestHelper.IsSuccess(await mgr.CreateAsync(user));
var userLogin1 = new UserLoginInfo("provider1", "p1-1");
UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin1));
UnitTestHelper.IsFailure(await mgr.AddLoginAsync(user.Id, userLogin1));
}
/// <summary>
/// Create a new UserLogin for the specified info and user
/// </summary>
/// <param name="loginInfo">Information about the login</param>
/// <param name="userId">ID of the user the login is for</param>
public UserLogin(UserLoginInfo loginInfo, string userId)
{
LoginProvider = loginInfo.LoginProvider;
ProviderDisplayName = loginInfo.ProviderDisplayName;
ProviderKey = loginInfo.ProviderKey;
UserId = userId;
}
public Task RemoveLoginAsync(IdentityUser user, Microsoft.AspNet.Identity.UserLoginInfo login)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (login == null)
{
throw new ArgumentNullException("login");
}
var u = _userservice.GetById(user.Id);
if (u == null)
{
throw new ArgumentException("IdentityUser does not correspond to a User entity.", "user");
}
var l = u.AspNetUserLogins.FirstOrDefault(x => x.LoginProvider == login.LoginProvider && x.ProviderKey == login.ProviderKey);
u.AspNetUserLogins.Remove(l);
return(_userservice.EditAsync(u));
}
public void RemoveLogin(IdentityUser user, UserLoginInfo login)
{
_db[_tables.UsersLogins].Delete(
UserId: user.Id,
LoginProvider: login.LoginProvider,
ProviderKey: login.ProviderKey);
}
public AccountController()
: this(new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())))
{
var rm = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));
try
{
if (!rm.RoleExists("admin"))
{
rm.Create(new IdentityRole("admin"));
var um = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
var user = new ApplicationUser() { UserName = "******" };
um.Create(user, "asdfgh");
UserLoginInfo info = new UserLoginInfo("Google",
"https://www.google.com/accounts/o8/id?id=AItOawka6ZSrKNn7UY3ZUcjFRZMSLhMqQNKArWQ");
um.AddToRole(user.Id, "admin");
um.AddLogin(user.Id, info);
}
}
catch (TimeoutException)
{
//CreateAdmin();
}
}
public void Handler_ReturnsNullRemoteMembership_WhenNotFound_ByUserId()
{
var userId = FakeData.Id();
var otherUserId = FakeData.Id(userId);
var loginProvider = FakeData.String();
var providerKey = FakeData.String();
var userLoginInfo = new UserLoginInfo(loginProvider, providerKey);
var remoteMemberships = new[]
{
new ProxiedRemoteMembership(loginProvider, providerKey)
{ UserId = otherUserId, },
new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
{ UserId = userId, },
};
var data = remoteMemberships.AsQueryable();
var query = new RemoteMembershipByUser(userId, userLoginInfo);
var dbSet = new Mock<DbSet<RemoteMembership>>(MockBehavior.Strict).SetupDataAsync(data);
var entities = new Mock<IReadEntities>(MockBehavior.Strict);
var entitySet = new EntitySet<RemoteMembership>(dbSet.Object, entities.Object);
entities.Setup(x => x.Query<RemoteMembership>()).Returns(entitySet);
var handler = new HandleRemoteMembershipByUserQuery(entities.Object);
RemoteMembership result = handler.Handle(query).Result;
result.ShouldBeNull();
entities.Verify(x => x.Query<RemoteMembership>(), Times.Once);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser()
{
UserName = model.UserName
};
try
{
using (var transaction = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
if (model.External.Equals("No"))//TO-DO Migrar a la VIEW ExternalLoginCallback. Esto no va aca, se debe tener el LoginInfo de la registracion Google
{
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded == false)
{
foreach (var error in result.Errors)
{
throw new Exception(error);
}
}
await _userManager.AddToRoleAsync(user.Id, model.Rol);
await SignInAsync(user, isPersistent : false);
}
else
{
var result = await _userManager.CreateAsync(user);
if (result.Succeeded == false)
{
foreach (var error in result.Errors)
{
throw new Exception(error);
}
}
Microsoft.AspNet.Identity.UserLoginInfo login = new Microsoft.AspNet.Identity.UserLoginInfo("Google", "https://www.google.com");
result = await _userManager.AddLoginAsync(user.Id, login);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user.Id, model.Rol);
await SignInAsync(user, isPersistent : false);
}
}
transaction.Complete();
}
return(RedirectToAction("Index", "Home"));
}
catch (Exception e)
{
AddErrors(e.Message);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public static Task<RemoteMembership> ByUserLoginInfoAsync(this IQueryable<RemoteMembership> set,
UserLoginInfo userLoginInfo, bool allowNull = true)
{
return allowNull
? set.SingleOrDefaultAsync(ByUserLoginInfo(userLoginInfo))
: set.SingleAsync(ByUserLoginInfo(userLoginInfo));
}
public IdentityUser CreateUserWithSocialProvider(UserLoginInfo login, ClaimsIdentity identity)
{
var userProfile = _userProfileSocialService.GetFromSocialProvider(login.LoginProvider, identity);
var user = new IdentityUser(GenerateUserName())
{
Email = userProfile.Email
};
var userCreationResult = _userManager.Create(user);
if (userCreationResult.Succeeded)
{
var userLoginResult = _userManager.AddLogin(user.Id, login);
if (!userLoginResult.Succeeded)
{
foreach (var error in userLoginResult.Errors)
{
throw new Exception(error);
}
}
}
else
{
foreach (var error in userCreationResult.Errors)
{
throw new Exception(error);
}
}
userProfile.UserId = user.Id;
_userProfileRepository.Add(userProfile);
_userProfileRepository.SaveChanges();
return user;
}
public Task AddLoginAsync(IdentityUser user, Microsoft.AspNet.Identity.UserLoginInfo login)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (login == null)
{
throw new ArgumentNullException("login");
}
var u = _userservice.GetById(user.Id);
if (u == null)
{
throw new ArgumentException("IdentityUser does not correspond to a User entity.", "user");
}
var l = new UserService.AspNetUserLogin
{
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
AspNetUser = u
};
u.AspNetUserLogins.Add(l);
return(_userservice.EditAsync(u));;
}
public void AddLogin(IdentityUser user, UserLoginInfo login)
{
_db[_tables.UsersLogins].Insert(
LoginProvider: login.LoginProvider,
ProviderKey: login.ProviderKey,
UserId: user.Id);
}
public AzureLogin(string ownerId, UserLoginInfo info)
: this()
{
UserId = ownerId;
LoginProvider = info.LoginProvider;
ProviderKey = info.ProviderKey;
}
public void WhenHaveNoUser()
{
var login = new UserLoginInfo("ProviderTest", "ProviderKey");
var store = new UserStore<IdentityUser>(_session);
var user = store.FindAsync(login).Result;
Assert.IsNull(user);
}
public void Should_return_null_if_user_not_found()
{
var login = new UserLoginInfo("Yahoo", "ghi");
var task = _target.FindAsync(login);
task.Wait();
Assert.That(task.Result, Is.Null);
}
public void CanAddLogin()
{
var user = IdentityUserMother.EmptyUser();
var login = new UserLoginInfo("test", "testing");
user.AddLogin(login).ShouldBe(true);
user.Logins.ShouldContain(login);
}
public static void Equal(UserLoginInfo expected, UserLoginInfo actual)
{
Assert.True((expected == null && actual == null) || (expected != null && actual != null));
Assert.Equal(expected.LoginProvider, actual.LoginProvider);
Assert.Equal(expected.ProviderKey, actual.ProviderKey);
Assert.Equal(expected.ProviderDisplayName, actual.ProviderDisplayName);
}
public void CanCheckIfLoginExists()
{
var user = IdentityUserMother.EmptyUser();
var login = new UserLoginInfo("test", "testing");
user.AddLogin(login).ShouldBe(true);
user.HasLogin(login).ShouldBe(true);
}
public static bool AreEqual(this UserLoginInfo thisObj, UserLoginInfo obj)
{
if (thisObj == null && obj == null) return true; // both objects are null
if (thisObj == null || obj == null) return false; // only one of the objects are null
return thisObj.LoginProvider.Equals(obj.LoginProvider, StringComparison.OrdinalIgnoreCase) &&
thisObj.ProviderKey.Equals(obj.ProviderKey, StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Return a user ID given a user's login.
/// </summary>
/// <param name="userLogin">The user's login info.</param>
/// <returns></returns>
public string FindUserIdByLogin(UserLoginInfo userLogin)
{
string commandText = "SELECT \"UserId\" FROM \"AspNetUserLogins\" WHERE \"LoginProvider\" = @loginProvider AND \"ProviderKey\" = @providerKey";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("loginProvider", userLogin.LoginProvider);
parameters.Add("providerKey", userLogin.ProviderKey);
return _database.GetStrValue(commandText, parameters);
}
/// <summary>
/// Return a userId given a user's login
/// </summary>
/// <param name="userLogin">The user's login info</param>
/// <returns></returns>
public string FindUserIdByLogin(UserLoginInfo userLogin)
{
string commandText = "Select UserId from UserLogins where LoginProvider = @loginProvider and ProviderKey = @providerKey";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("loginProvider", userLogin.LoginProvider);
parameters.Add("providerKey", userLogin.ProviderKey);
return _database.GetStrValue(commandText, parameters);
}
/// <summary>
/// Return a user ID given a user's login.
/// </summary>
/// <param name="userLogin">The user's login info.</param>
/// <returns></returns>
public string FindUserIdByLogin(UserLoginInfo userLogin)
{
string commandText = "SELECT "+fielduserID.Quoted()+" FROM "+fullTableName+" WHERE "+fieldLoginProvider.Quoted()+" = @loginProvider AND "+fieldProviderKey.Quoted()+" = @providerKey";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("loginProvider", userLogin.LoginProvider);
parameters.Add("providerKey", userLogin.ProviderKey);
return _database.GetStrValue(commandText, parameters);
}
public void Should_return_user_for_login()
{
var login = new UserLoginInfo("Google", "123");
var task = _target.FindAsync(login);
task.Wait();
Assert.That(task.Result.Id, Is.EqualTo(TestData.John_UserId));
}
public async Task Create_Identity()
{
TableUser user = new TableUser(userName);
var result = await _mgr.CreateAsync(user);
Assert.IsTrue(result.Succeeded);
UserLoginInfo info = new UserLoginInfo("testprovider", "testproviderkey");
result = await _mgr.AddLoginAsync(user.Id, info);
var result2 = await _mgr.CreateIdentityAsync(user, CookieAuthenticationDefaults.AuthenticationType);
Assert.AreEqual(CookieAuthenticationDefaults.AuthenticationType,result2.AuthenticationType);
}
public async Task Add_Login()
{
TableUser user = new TableUser(userName);
var result = await _mgr.CreateAsync(user);
Assert.IsTrue(result.Succeeded);
//TableUserLogin login = new TableUserLogin(user.Id, "testprovider", "testproviderkey");
UserLoginInfo info = new UserLoginInfo("testprovider", "testproviderkey");
result = await _mgr.AddLoginAsync(user.Id, info);
Assert.IsTrue(result.Succeeded);
}
/// <summary>
/// Inserts a new login record in the AspNetUserLogins table.
/// </summary>
/// <param name="user">User to have new login added.</param>
/// <param name="login">Login to be added.</param>
/// <returns></returns>
public int Insert(IdentityUser user, UserLoginInfo login)
{
string commandText = "INSERT INTO \"AspNetUserLogins\" (\"LoginProvider\", \"ProviderKey\", \"UserId\") VALUES (@loginProvider, @providerKey, @userId)";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("loginProvider", login.LoginProvider);
parameters.Add("providerKey", login.ProviderKey);
parameters.Add("userId", user.Id);
return _database.Execute(commandText, parameters);
}
/// <summary>
/// Deletes a login record from a user in the UserLogins table.
/// </summary>
/// <param name="user">User to have login deleted.</param>
/// <param name="login">Login to be deleted from user.</param>
/// <returns></returns>
public int Delete(IdentityUser user, UserLoginInfo login)
{
string commandText = "DELETE FROM \"AspNetUserLogins\" WHERE \"UserId\" = @userId AND \"LoginProvider\" = @loginProvider AND \"ProviderKey\" = @providerKey";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("UserId", user.Id);
parameters.Add("loginProvider", login.LoginProvider);
parameters.Add("providerKey", login.ProviderKey);
return _database.Execute(commandText, parameters);
}
public async Task<IdentityResult> AddLoginAsync(string userId, UserLoginInfo login)
{
using (IdentityDbContext<AbitInfoIdentityUser> context = _identityProvider.Context)
{
UserManager<AbitInfoIdentityUser> userManager =
_identityProvider.GetUserManager(context);
var result = await userManager.AddLoginAsync(userId, login);
return result;
}
}
public RavenUserLogin(string userId, UserLoginInfo loginInfo)
{
if (userId == null) throw new ArgumentNullException("userId");
if (loginInfo == null) throw new ArgumentNullException("loginInfo");
Id = GenerateKey(loginInfo.LoginProvider, loginInfo.ProviderKey);
UserId = userId;
LoginProvider = loginInfo.LoginProvider;
ProviderKey = loginInfo.ProviderKey;
}
/// <summary>
/// Return a userId given a user's login
/// </summary>
/// <param name="MemberLogin">The user's login info</param>
/// <returns></returns>
public int FindUserIdByLogin(UserLoginInfo MemberLogin)
{
return db.Connection.ExecuteScalar<int>(@"Select UserId from MemberLogin
where LoginProvider = @loginProvider and ProviderKey = @providerKey",
new
{
loginProvider = MemberLogin.LoginProvider,
providerKey=MemberLogin.ProviderKey
});
}
/// <summary>
/// Inserts a new login in the UserLogins table
/// </summary>
/// <param name="user">User to have new login added</param>
/// <param name="login">Login to be added</param>
/// <returns></returns>
public int Insert(IdentityUser user, UserLoginInfo login)
{
string commandText = "Insert into UserLogins (LoginProvider, ProviderKey, UserId) values (@loginProvider, @providerKey, @userId)";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("loginProvider", login.LoginProvider);
parameters.Add("providerKey", login.ProviderKey);
parameters.Add("userId", user.Id);
return _database.Execute(commandText, parameters);
}
/// <summary>
/// Deletes a login from a user in the UserLogins table
/// </summary>
/// <param name="user">User to have login deleted</param>
/// <param name="login">Login to be deleted from user</param>
/// <returns></returns>
public int Delete(IdentityUser user, UserLoginInfo login)
{
string commandText = "Delete from UserLogins where UserId = @userId and LoginProvider = @loginProvider and ProviderKey = @providerKey";
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("UserId", user.Id);
parameters.Add("loginProvider", login.LoginProvider);
parameters.Add("providerKey", login.ProviderKey);
return _database.Execute(commandText, parameters);
}
public async Task<AbitInfoIdentityUser> FindAsync(UserLoginInfo loginInfo)
{
using (IdentityDbContext<AbitInfoIdentityUser> context = _identityProvider.Context)
{
UserManager<AbitInfoIdentityUser> userManager =
_identityProvider.GetUserManager(context);
AbitInfoIdentityUser user = await userManager.FindAsync(loginInfo);
return user;
}
}
public Task AddLoginAsync(TUser user, Microsoft.AspNet.Identity.UserLoginInfo login, CancellationToken cancellationToken)
{
if (user != null)
{
if (user.Logins == null)
{
user.Logins = new List <UserLoginInfoMutable>();
}
user.Logins.Add(new UserLoginInfoMutable(login.LoginProvider, login.ProviderKey, ""));
}
return(Task.CompletedTask);
}
public Task <IdentityUser> FindAsync(Microsoft.AspNet.Identity.UserLoginInfo login)
{
if (login == null)
{
throw new ArgumentNullException("login");
}
var identityUser = default(IdentityUser);
var l = _userservice.GetByProviderAndKey(login.LoginProvider, login.ProviderKey);
if (l != null)
{
identityUser = getIdentityUser(l.AspNetUser);
}
return(Task.FromResult <IdentityUser>(identityUser));
}
protected virtual async Task <AuthenticateResult> ProcessNewExternalAccountAsync(string provider, string providerId, IEnumerable <Claim> claims)
{
var user = await TryGetExistingUserFromExternalProviderClaimsAsync(provider, claims);
if (user == null)
{
user = await InstantiateNewUserFromExternalProviderAsync(provider, providerId, claims);
if (user == null)
{
throw new InvalidOperationException("CreateNewAccountFromExternalProvider returned null");
}
var createResult = await userManager.CreateAsync(user);
if (!createResult.Succeeded)
{
return(new AuthenticateResult(createResult.Errors.First()));
}
}
var externalLogin = new Microsoft.AspNet.Identity.UserLoginInfo(provider, providerId);
var addExternalResult = await userManager.AddLoginAsync(user.Id, externalLogin);
if (!addExternalResult.Succeeded)
{
return(new AuthenticateResult(addExternalResult.Errors.First()));
}
var result = await AccountCreatedFromExternalProviderAsync(user.Id, provider, providerId, claims);
if (result != null)
{
return(result);
}
return(await SignInFromExternalProviderAsync(user.Id, provider));
}
public Task AddLoginAsync(TUser user, Microsoft.AspNet.Identity.UserLoginInfo login)
{
return(AddLoginAsync(user, login, new CancellationTokenSource().Token));
}
public Task AddLoginAsync(T User, Microsoft.AspNet.Identity.UserLoginInfo i)
{
throw new NotImplementedException();
}
public Task RemoveLoginAsync(TUser user, Microsoft.AspNet.Identity.UserLoginInfo login)
{
return(RemoveLoginAsync(user, login.LoginProvider, login.ProviderKey, new CancellationTokenSource().Token));
}
public Task <TUser> FindAsync(Microsoft.AspNet.Identity.UserLoginInfo login)
{
return(FindByLoginAsync(login.LoginProvider, login.ProviderKey, new CancellationTokenSource().Token));
}
public Task <T> FindAsync(Microsoft.AspNet.Identity.UserLoginInfo i)
{
throw new NotImplementedException();
}
/// <summary>
/// Sync extension
/// </summary>
/// <param name="manager"></param>
/// <param name="login"></param>
/// <returns></returns>
public static TUser Find <TUser, TKey>(this UserManager <TUser, TKey> manager, UserLoginInfo login)
where TKey : IEquatable <TKey>
where TUser : class, IUser <TKey>
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
return(AsyncHelper.RunSync(() => manager.FindAsync(login)));
}
public async Task <ActionResult> CallBackFromLockScreen(string email, string ReturnUrl) //if user login using facebook and fb api does not return email
{
var LoginString = Request["Login"];
var name = Request["name"];
var city = Request["city"];
var gender = Request["gender"];
var dateOfBirth1 = Request["dateOfBirth"];
var pictureUrl = Request["pictureUrl"];
System.DateTime dateofBirth = (System.DateTime)Convert.ChangeType(dateOfBirth1, typeof(System.DateTime));
Microsoft.AspNet.Identity.UserLoginInfo Login = (Microsoft.AspNet.Identity.UserLoginInfo)Convert.ChangeType(LoginString, typeof(Microsoft.AspNet.Identity.UserLoginInfo));
bool isOldUser = db.AspNetUsers.Any(x => x.UserName.Equals(email));
if (isOldUser)
{
TempData["errorMsg"] = "This Email is already in use.";
ViewBag.ReturnUrl = ReturnUrl;
return(View("LockScreen"));
}
var newUser1 = new ApplicationUser()
{
Email = name, UserName = email
};
var result1 = await UserManager.CreateAsync(newUser1);
if (result1.Succeeded)
{
result1 = await UserManager.AddLoginAsync(newUser1.Id, Login);
if (result1.Succeeded)
{
await SignInAsync(newUser1, isPersistent : true);
if (pictureUrl != null && pictureUrl != "")
{
WebClient wc = new WebClient();
byte[] bytes = wc.DownloadData(pictureUrl);
MemoryStream ms = new MemoryStream(bytes);
System.Drawing.Image img = System.Drawing.Image.FromStream(ms);
string fileName = @"\Images\Users\p" + DateTime.UtcNow.Ticks + ".jpg";
img.Save(Server.MapPath(fileName));
ElectronicsController.UploadDPToAWS(Server.MapPath(fileName), "p" + newUser1.Id + ".jpg");
if (System.IO.File.Exists(Server.MapPath(fileName)))
{
System.IO.File.Delete(Server.MapPath(fileName));
}
}
string id = newUser1.Id;
AspNetUser aspNetUser = await db.AspNetUsers.FindAsync(id);
aspNetUser.Email = name;
aspNetUser.EmailConfirmed = false;
aspNetUser.hideDateOfBirth = true;
aspNetUser.hideEmail = true;
aspNetUser.hidePhoneNumber = true;
aspNetUser.hideFriends = true;
aspNetUser.gender = gender;
aspNetUser.city = city;
aspNetUser.dateOfBirth = dateofBirth;
aspNetUser.dpExtension = ".jpg";
aspNetUser.since = DateTime.UtcNow;
aspNetUser.status = "active";
db.Entry(aspNetUser).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
await SendMailtoConfirmEmailAddress(aspNetUser.Id, aspNetUser.Email, aspNetUser.UserName);
return(RedirectToLocal(ReturnUrl));
// return RedirectToAction("ExternalLoginInfo", new { returnUrl = ReturnUrl });
}
}
//var userId = User.Identity.GetUserId();
//var user = UserManager.FindById(userId);
//user.UserName = email;
//var updateResult = await UserManager.UpdateAsync(user);
//if (updateResult.Succeeded)
//{
// await SendMailtoConfirmEmailAddress(user.Id, user.Email, user.UserName);
// return RedirectToLocal(ReturnUrl);
//}
TempData["errorMsg"] = "Some error hs occured. Please enter your email again and continue.";
ViewBag.ReturnUrl = ReturnUrl;
return(View("LockScreen"));
}
public Task RemoveLoginAsync(T User, Microsoft.AspNet.Identity.UserLoginInfo login)
{
// return Task.FromResult( 0);
throw new NotImplementedException();
}
