public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login", "Account"));
}
}
return(View(registerViewModel));
}
// Profile Details
public ActionResult Details()
{
string username = User.Identity.Name;
CustomIdentityUser user = _userManager.FindByNameAsync(username).Result;
var userProfile = _userProfileService.GetAll().FirstOrDefault(x => x.UserId.Equals(user.Id));
if (userProfile == null)
{
var profile = new UserProfile()
{
UserId = user.Id,
DepId = 5,
LanguageID = 1
};
_userProfileService.Add(profile);
userProfile = profile;
}
var departement = _departmentService.GetById(userProfile.DepId);
var language = _languageService.GetById(userProfile.LanguageID);
UserProfileViewModel model = new UserProfileViewModel()
{
UserProfile = userProfile,
CustomIdentityUser = user,
Department = departement,
Language = language
};
return(View(model));
}
public IActionResult RegisterCustomer(RegisterCustomerViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.Name,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Customer").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Customer"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Böyle bir rol ekleyemedik");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Customer").Wait();
return(RedirectToAction("LoginCustomer"));
}
}
return(View(registerViewModel));
}
public async Task <IActionResult> RegisterAccount([FromBody] RegisterCredentials credentials)
{
if (!credentials.Password.Equals(credentials.RePassword))
{
return(BadRequest(new List <IdentityError>()
{
new IdentityError()
{
Description = "Passwords are not the same!"
}
}));
}
var user = new CustomIdentityUser()
{
First = credentials.First, Last = credentials.Last, UserName = credentials.Email, Email = credentials.Email
};
var result = await userManager.CreateAsync(user, credentials.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await signInManager.SignInAsync(user, false);
return(Ok(CreateToken(user)));
}
/// <summary>
/// Метода регистрации в системе администратора при запуске приложения
/// </summary>
/// <returns></returns>
public static async Task CreateIfNotExistAsync(CustomUserManager <CustomIdentityUser> _userManager, RoleManager <IdentityRole> _roleManager, string name, string roleName, string password)
{
//Проверяем на первый запуск(существование хотя бы одного пользователя)
if (!(await _userManager.GetUsersInRoleAsync(roleName)).Any())
{
//Перед назначением роли , нужно убедиться, что есть что назначать
if (!await _roleManager.RoleExistsAsync(roleName))
{
//Создаем роль
await _roleManager.CreateAsync(new IdentityRole { Name = roleName });
}
//Проверяем нет ли польователя
var user = await _userManager.FindByNameAsync(name);
if (user == null)
{
//Если такого юзера нет, создаем дефолтного админа
user = new CustomIdentityUser {
UserName = name /*, Email = Input.Email*/
};
/*var result = */ await _userManager.CreateAsync(user, password);
}
//Теперь назначаем роль, если она еще не назначена
if (!await _userManager.IsInRoleAsync(user, roleName))
{
//Правим юзера
await _userManager.AddToRoleAsync(user, roleName);
}
//Активируем
await _userManager.SetIsActiveAsync(user, true);
}
//Тут активировать админа не стоит по причине того, что уже может быть создан не дефолтный админ(с целями повышения безопасности)
}
public void FreeUser(CustomIdentityUser user)
{
lock (_locker)
{
_repo.UpdateIsFreeStatus(user, true);
}
}
public IActionResult Edit(CustomIdentityUser customer)
{
HttpResponseMessage response = client.PutAsJsonAsync("https://localhost:44329/api/user/" + customer.Id, customer).Result;
TempData["SuccessMessage"] = customer.UserName + " Updated Successfully";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Register(RegisterViewModel registerViewModel)
{
if (!ModelState.IsValid)
{
return(View(registerViewModel));
}
var user = new CustomIdentityUser
{
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
var result = await _userManager.CreateAsync(user, registerViewModel.Password);
if (result.Succeeded)
{
_basketService.InitializeCart(user.Id);
return(RedirectToAction("LogOn", "Account"));
}
TempData.Put("message", new AlertMessage()
{
Title = "Bilgilerinizi Kontrol Ediniz",
Message = "",
AlertType = "warning"
});
return(View(registerViewModel));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CustomIdentityUser {
UserName = model.UserName, Email = model.Email, UserProfession = "Software Engineer"
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
{
return(RedirectToAction("GetUserList", "Admin"));
}
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Student"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("userLogin", $"Error occured during user registration.following errors - {error.Code} - {error.Description}");
}
}
return(View());
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new CustomIdentityUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task<IActionResult> Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
Email = registerViewModel.Email
};
var userCreateResult = await _userManager.CreateAsync(user, registerViewModel.Password);
if (!userCreateResult.Succeeded)
{
ModelState.AddModelError("", "Kullanıcı oluşturulamadı");
return View(registerViewModel);
}
else
{
_userManager.AddToRoleAsync(user, "User").Wait();
return RedirectToAction("Login", "Account");
}
}
return View(registerViewModel);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
//ApplicationUser user = await userManager.FindAsync(context.UserName, context.Password);
CustomIdentityUser user = await userManager.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(userManager,
OAuthDefaults.AuthenticationType);
ClaimsIdentity cookiesIdentity = await user.GenerateUserIdentityAsync(userManager,
CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = CreateProperties(user.UserName);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties);
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(cookiesIdentity);
}
public CustomIdentityUser GetFirstFreeUser(DateTime CallStart, int Tm, int Td)
{
CustomIdentityUser retv = null;
var Elapsed = (DateTime.Now - CallStart).TotalMilliseconds;
if (Elapsed >= Td)
{
//Любая роль получает звонок
retv = _context.Users.FirstOrDefault(u => u.IsFree && u.IsLoggedIn);
}
else if (Elapsed >= Tm)
{
var opId = _context.Roles.First(r => r.Name == "operator").Id;
var manId = _context.Roles.First(r => r.Name == "manager").Id;
//Оператор либо менеджер
var usrs = _context.UserRoles.Where(r => r.RoleId == opId || r.RoleId == manId).ToList();
if (usrs != null && usrs.Count > 0)
{
retv = _context.Users.FirstOrDefault(u => u.IsFree && u.IsLoggedIn && usrs.Any(ur => ur.UserId == u.Id));
}
}
else
{
//Только оператор
var opId = _context.Roles.First(r => r.Name == "operator").Id;
//
var usrs = _context.UserRoles.Where(r => r.RoleId == opId).ToList();
if (usrs != null && usrs.Count > 0)
{
retv = _context.Users.FirstOrDefault(u => u.IsFree && u.IsLoggedIn && usrs.Any(ur => ur.UserId == u.Id));
}
}
return(retv);
}
public IActionResult Register(AccountRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
var createTask = _userManager.CreateAsync(user, registerViewModel.Password);
if (createTask.Result.Succeeded)
{
_messageSender.SendMessage(email: registerViewModel.Email,
nameTo: registerViewModel.FisrtName,
messageText: "You have been registered on the site FootballShow");
return(RedirectToRoute(new { controller = "Home", action = "Index" }));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager
.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("User").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "User"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!result.Succeeded)
{
ModelState.AddModelError("", "Role can't added!");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "User").Wait();
return(RedirectToAction("Login"));
}
TempData.Add("message", "The information you entered is registered or your password is not secure. Please check your information and try again!");
}
return(View(registerViewModel));
}
public ActionResult Delete(CustomIdentityUser UserId)
{
_userManager.DeleteAsync(UserId);
TempData["deletejobmessage"] = "Job has been deleted sucessfully";
return(RedirectToAction("Index", new { area = "Admin" }));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CustomIdentityUser
{
UserName = model.Email,
Email = model.Email,
FullName = model.FullName,
Address = model.Address,
City = model.City
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View());
}
public void AccountController_Register_CreateCalledOnce()
{
//Arrange
//чаще всего "мокаются" интерфейсы
Mock <UserManager <CustomIdentityUser> > userManager = new Mock <UserManager <CustomIdentityUser> >(); // для успешного теста нужно добавить все зависимости в конструктор
Mock <SignInManager <CustomIdentityUser> > signInManager = new Mock <SignInManager <CustomIdentityUser> >();
AccountRegisterViewModel registerViewModel = new AccountRegisterViewModel
{
FisrtName = "TestFisrtName",
LastName = "TestLastName",
UserName = "******",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
userManager.Setup(x => x.CreateAsync(user, registerViewModel.Password)).ReturnsAsync(IdentityResult.Success);
AccountController controller = new AccountController(userManager.Object, signInManager.Object);
//Act
controller.Register(registerViewModel);
//Assert
userManager.Verify(x => x.CreateAsync(user, registerViewModel.Password), Times.Once);
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var user = new ApplicationUser() { UserName = model.Email, Email = model.Email };
var user = new CustomIdentityUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
int newUserId = UserManager.FindByName(model.Email).Id;
IdentityResult addToRoleResult = UserManager.AddToRole(newUserId, "User");
if (!addToRoleResult.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
return(InternalServerError());
}
//var user = new ApplicationUser() { UserName = model.Email, Email = model.Email };
var user = new CustomIdentityUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public IActionResult Register(AccountRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
FisrtName = registerViewModel.FisrtName,
LastName = registerViewModel.LastName,
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
var createTask = _userManager.CreateAsync(user, registerViewModel.Password);
if (createTask.Result.Succeeded)
{
return(RedirectToRoute(new { controller = "Home", action = "Index" }));
}
foreach (var error in createTask.Result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider provider)
{
var customIdentityDbContext = provider.GetRequiredService <CustomIdentityDbContext>();
customIdentityDbContext.Database.Migrate();
var userManager = provider.GetRequiredService <UserManager <CustomIdentityUser> >();
var testUser = new CustomIdentityUser()
{
UserName = "******",
Email = "*****@*****.**",
};
var result = userManager.CreateAsync(testUser, "P@ssw0rd").Result;
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync("EFCore Relationship Test Project");
});
});
}
public ActionResult Add(CustomIdentityUser customIdentityUser)
{
if (ModelState.IsValid)
{
_userManager.CreateAsync(customIdentityUser);
}
return(RedirectToAction("Index/Registration", new { area = "Admin" }));
}
public async Task <IActionResult> Register(RegisterViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = await this._userManager.FindByNameAsync(viewModel.UserName);
if (user == null)
{
user = new CustomIdentityUser
{
Id = Guid.NewGuid().ToString(),
UserName = viewModel.UserName,
Email = viewModel.UserName
};
var result = await this._userManager.CreateAsync(user, viewModel.Password);
if (result.Succeeded)
{
if (!await this._roleManager.RoleExistsAsync(UserRole.Admin))
{
await this._roleManager.CreateAsync(new IdentityRole(UserRole.Admin));
}
if (!await this._roleManager.RoleExistsAsync(UserRole.SuperAdmin))
{
await this._roleManager.CreateAsync(new IdentityRole(UserRole.SuperAdmin));
}
await this._userManager.AddToRoleAsync(user, UserRole.Admin);
var token = await this._userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmEmailUrl = Url.Action(
"ConfirmEmailAddress",
"Account",
new { Token = token, Email = viewModel.UserName },
Request.Scheme);
System.IO.File.WriteAllText("confirmEmailUrl.txt", confirmEmailUrl);
return(View("Success"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View());
}
}
}
return(View());
}
protected async Task <IHttpActionResult> SendPasswordResetEmail(CustomIdentityUser user, bool isRegistering)
{
IHttpActionResult response = null;
if (user == null)
{
// Don't reveal that the user does not exist or is not confirmed
response = Ok(Resource.EmailCheckMessage);
}
else
{
try
{
var code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
UriBuilder callbackUrl = new UriBuilder();
callbackUrl.Scheme = this.Url.Request.RequestUri.Scheme;
callbackUrl.Host = this.Url.Request.RequestUri.Host;
callbackUrl.Path = "Account/SetPassword";
var query = HttpUtility.ParseQueryString(string.Empty);
query["userId"] = user.Id;
query["code"] = code;
callbackUrl.Query = query.ToString();
string body;
//return RedirectToAction("EmailConfirm");
//Read template file from the App_Data folder
if (isRegistering)
{
//using ( var sr = new StreamReader(HttpContext.Current.Server.MapPath("\\App_Data\\Templates\\") + PODEnvironment.GetSetting("emailTemplate:SetPassword") ))
//{
// body = sr.ReadToEnd();
//}
body = EmailManager.FillBody("SetPassword", new object[] { user.FullName, user.UserName, callbackUrl });
await UserManager.SendEmailAsync(user.Id, Resource.EmailTempSetPasswordSubject, string.Format(body, user.FullName, callbackUrl, user.UserName));
}
else
{
//using ( var sr = new StreamReader(HttpContext.Current.Server.MapPath("\\App_Data\\Templates\\") + PODEnvironment.GetSetting("emailTemplate:ResetPassword") ))
//{
// body = sr.ReadToEnd();
//}
body = EmailManager.FillBody("ResetPassword", new object[] { user.FullName, user.UserName, callbackUrl });
await UserManager.SendEmailAsync(user.Id, Resource.EmailTempForgotPasswordSubject, body);
}
response = Ok(Resource.EmailCheckMessage);
}
catch (Exception ex)
{
string message = UserHelper.ErrorHandler(ex);
response = BadRequest(message);
}
}
return(response);
}
public ActionResult Update(CustomIdentityUser customIdentityUser)
{
if (ModelState.IsValid)
{
_userManager.UpdateAsync(customIdentityUser);
}
var user = new CustomIdentityUser();
return(RedirectToAction("Index", new { area = "Admin" }));
}
public async Task <IActionResult> Edit(string id, [Bind("FirstName,LastName,DateofBirth,Gender,SocialSecurityNumber,Email,Phone,SecondaryPhone,Address,City,State,ZipCode,MaritalStatus,EmergencyContact,Relationship,InsuranceProvider,InsurancePolicyNumber")] CustomIdentityUser model)
{
//the ConcurrencyStamp was not correct. the update statement looks for the existing user's
//id and ConcurrencyStamp in the where, ex...
//
//update user set name = @n where id = @id and @ConcurrencyStamp = @c
//
//this gets the current identity user
var existingUser = _context.Users.SingleOrDefault(x => x.Id == id);
//this correctc the damn concurrency stamp
model.ConcurrencyStamp = existingUser.ConcurrencyStamp;
//this needs to be updated to include all managed fields.
//don't include fields not to be edited like id or user name.
existingUser.FirstName = model.FirstName;
existingUser.LastName = model.LastName;
existingUser.DateofBirth = model.DateofBirth;
existingUser.Gender = model.Gender;
existingUser.SocialSecurityNumber = model.SocialSecurityNumber;
existingUser.PhoneNumber = model.PhoneNumber;
existingUser.SecondaryPhone = model.SecondaryPhone;
existingUser.Address = model.Address;
existingUser.City = model.City;
existingUser.State = model.State;
existingUser.ZipCode = model.ZipCode;
existingUser.MaritalStatus = model.MaritalStatus;
existingUser.EmergencyContact = model.EmergencyContact;
existingUser.Relationship = model.Relationship;
existingUser.InsuranceProvider = model.InsuranceProvider;
existingUser.InsurancePolicyNumber = existingUser.InsurancePolicyNumber;
if (ModelState.IsValid)
{
try
{
//the update statement was throwing an error because the entity was loaded by my new code
//above. This HACK removed the entity so we can keep the same simpler code.
//_context.Entry(existingUser).State = EntityState.Detached;
//_context.Update(customIdentityUser);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomIdentityUserExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Details)));
}
return(View(model));
}
public string CreateToken(CustomIdentityUser user)
{
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration.GetSection("Authentication:SecretKey").Value));
var signingCredential = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var claims = new Claim[] {
new Claim(JwtRegisteredClaimNames.Sub, user.Id)
};
var jwt = new JwtSecurityToken(signingCredentials: signingCredential, claims: claims);
return(new JwtSecurityTokenHandler().WriteToken(jwt));
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,DateofBirth,Gender,SocialSecurityNumber,Email,Phone,SecondaryPhone,Address,City,State,ZipCode,MaritalStatus,EmergencyContact,Relationship,InsuranceProvider,InsurancePolicyNumber")] CustomIdentityUser customIdentityUser)
{
if (ModelState.IsValid)
{
_context.Add(customIdentityUser);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customIdentityUser));
}
public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(provider, this));
}
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
return(InternalServerError());
}
if (externalLogin.LoginProvider != provider)
{
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
return(new ChallengeResult(provider, this));
}
//ApplicationUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider,
// externalLogin.ProviderKey));
CustomIdentityUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider,
externalLogin.ProviderKey));
bool hasRegistered = user != null;
if (hasRegistered)
{
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(UserManager,
OAuthDefaults.AuthenticationType);
ClaimsIdentity cookieIdentity = await user.GenerateUserIdentityAsync(UserManager,
CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(user.UserName);
Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
}
else
{
IEnumerable <Claim> claims = externalLogin.GetClaims();
ClaimsIdentity identity = new ClaimsIdentity(claims, OAuthDefaults.AuthenticationType);
Authentication.SignIn(identity);
}
return(Ok());
}
public Task<string> GetPasswordHashAsync(CustomIdentityUser user)
{
return Task.FromResult(user.Password);
}
public Task<IList<string>> GetRolesAsync(CustomIdentityUser user)
{
IList<string> tempRoles = new List<string>() { "user" };
return Task.FromResult(tempRoles);
}
public Task<bool> HasPasswordAsync(CustomIdentityUser user)
{
return Task.FromResult(true);
}
public Task<bool> IsInRoleAsync(CustomIdentityUser user, string roleName)
{
return Task.FromResult(true);
}
public Task SetEmailAsync(CustomIdentityUser user, string email)
{
return Task.Factory.StartNew(() => user.Email = email);
}
public Task CreateAsync(CustomIdentityUser user)
{
var poco = Mapper.Map<User>(user);
var result = _userService.Add(poco);
return Task.FromResult(Mapper.Map<CustomIdentityUser>(result));
}
public Task<string> GetEmailAsync(CustomIdentityUser user)
{
return Task.FromResult(user.Email);
}
public Task SetLockoutEndDateAsync(CustomIdentityUser user, DateTimeOffset lockoutEnd)
{
throw new NotImplementedException();
}
public async Task<ActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
var user = new CustomIdentityUser(RegisterModel.ConvertToUser(model));
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var createdUser = RepositoryManager.Instance.UserRepository.GetByLogin(model.Login);
if (createdUser != null)
{
await SignInManager.SignInAsync(new CustomIdentityUser(createdUser), isPersistent: false, rememberBrowser: false);
}
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
return View(model);
}
public Task AddLoginAsync(CustomIdentityUser user, UserLoginInfo login)
{
throw new NotImplementedException();
}
public Task<IList<Claim>> GetClaimsAsync(CustomIdentityUser user)
{
IList<Claim> userClaims = new List<Claim>();
userClaims.Add(new Claim("Id", user.Id.ToString(), DefaultAuthenticationTypes.ExternalBearer));
userClaims.Add(new Claim("Name", user.Name));
userClaims.Add(new Claim("Email", user.Email));
return Task.FromResult(userClaims);
}
public Task<int> GetAccessFailedCountAsync(CustomIdentityUser user)
{
throw new NotImplementedException();
}
public Task DeleteAsync(CustomIdentityUser user)
{
return Task.Factory.StartNew(() => _userService.Delete(user.Id));
}
public Task<IList<UserLoginInfo>> GetLoginsAsync(CustomIdentityUser user)
{
throw new NotImplementedException();
}
public Task SetLockoutEnabledAsync(CustomIdentityUser user, bool enabled)
{
throw new NotImplementedException();
}
public Task<bool> GetEmailConfirmedAsync(CustomIdentityUser user)
{
return Task.FromResult(true);
}
public Task SetEmailConfirmedAsync(CustomIdentityUser user, bool confirmed)
{
return Task.Factory.StartNew(() => true);
}
public Task AddClaimAsync(CustomIdentityUser user, Claim claim)
{
throw new NotImplementedException();
}
public Task AddToRoleAsync(CustomIdentityUser user, string roleName)
{
throw new NotImplementedException();
}
public Task SetPasswordHashAsync(CustomIdentityUser user, string passwordHash)
{
return Task.Factory.StartNew(() => user.Password = passwordHash);
}
public Task UpdateAsync(CustomIdentityUser user)
{
var poco = Mapper.Map<User>(user);
return Task.Factory.StartNew(() => _userService.Update(poco));
}
