private ApplicationIdentityUser CreateUser(string userName, string password)
{
var user = UserManager.FindByNameAsync(userName).Result;
var identityResult = new IdentityResult();
if (user == null)
{
user = new ApplicationIdentityUser {
UserName = userName, Email = userName
};
identityResult = UserManager.CreateAsync(user, password).Result;
if (identityResult.Succeeded)
{
identityResult = UserManager.SetLockoutEnabledAsync(user.Id, false).Result;
}
}
UserManager.GeneratePasswordResetToken(user.Id);
return(user);
}
public IdentityResult Register(RegisterViewModel user, bool isHost, bool isAdmin)
{
ApplicationIdentityUser identityUser =
Mapper.Map <RegisterViewModel, ApplicationIdentityUser>(user);
IdentityResult identityResult = TheUnitOfWork.Account.Register(identityUser);
if (!isAdmin)
{
if (isHost)
{
var host = Mapper.Map <ApplicationIdentityUser, HostUser>(identityUser);
TheUnitOfWork.Host.AddAsAHost(host);
}
else
{
var client = Mapper.Map <ApplicationIdentityUser, ClientUser>(identityUser);
TheUnitOfWork.Client.AddAsAClient(client);
}
}
return(identityResult);
}
public void InitializeIdentityForEf(ApplicationDbContext db)
{
// This is only for testing purpose
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
var applicationRoleManager = IdentityFactory.CreateRoleManager(db);
var applicationUserManager = IdentityFactory.CreateUserManager(db);
//Create Role Admin if it does not exist
var role = applicationRoleManager.FindByName(roleName);
if (role == null)
{
role = new ApplicationIdentityRole {
Name = roleName
};
applicationRoleManager.Create(role);
}
var user = applicationUserManager.FindByName(name);
if (user == null)
{
user = new ApplicationIdentityUser {
UserName = name, Email = name
};
applicationUserManager.Create(user, password);
applicationUserManager.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = applicationUserManager.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
applicationUserManager.AddToRole(user.Id, role.Name);
}
db.SaveChanges();
}
protected void InitRoleAndUser(ApplicationDbContext context)
{
var password = "******";
var userManager = new ApplicationUserManager(new ApplicationUserStore(context));
var roleManager = new ApplicationRoleManager(new ApplicationRoleStore(context));
roleManager.Create(new ApplicationIdentityRole
{
Name = SystemRole.SuperUser.ToString(),
Description = SystemRole.SuperUser.GetDescription(),
IsSystemConfig = true,
InsertedOnUtc = DateTime.UtcNow
});
var superuser = new ApplicationIdentityUser()
{
Email = _SuperUserEmail,
EmailConfirmed = true,
UserName = _SuperUserEmail,
FirstName = "Super",
MiddleName = "",
LastName = "User",
InsertedOnUtc = DateTime.UtcNow,
};
var result = userManager.Create(superuser, password);
if (result.Succeeded)
{
superuser.LastModifiedUserId = superuser.Id;
result = userManager.Update(superuser);
if (result.Succeeded)
{
userManager.AddToRole(superuser.Id, SystemRole.SuperUser.ToString());
}
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationIdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
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 ApplicationIdentityUser {
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));
}
public async Task <ActionResult <LoginResponse> > Login([FromBody] LoginRequest loginModel)
{
_logger.LogInformation("User with email {Email} attempting to login", loginModel.Email);
// Check whether the user who wants to log in exists
ApplicationIdentityUser identityUser = await _userManager
.FindByEmailAsync(loginModel.Email).ConfigureAwait(false);
if (identityUser != null) // if exists
{
// validate password
bool correctPassword = await _userManager
.CheckPasswordAsync(identityUser, loginModel.Password)
.ConfigureAwait(false);
if (correctPassword)
{
User user = (await _userRepository
.GetAllByAsync(u => u.IdentityId.Equals(identityUser.Id, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false))
.First();
// Create access token for successfully validated user
AccessToken accessToken = await GenerateAccessToken(user);
return(Ok(new LoginResponse(accessToken)));
}
_logger.
LogInformation("User with email {Email} attempted to login with the wrong credentials",
loginModel.Email);
}
_logger.LogInformation("Login failed for user with email {0} ", loginModel.Email);
// The user does not exist in our system so the request is unauthorized
return(Unauthorized());
}
public static Claim[] GetUserClaims(ApplicationIdentityUser user, List <string> roles = null)
{
var claims = new List <Claim>
{
new Claim("user_id", user.Id ?? ""),
new Claim(JwtClaimTypes.Name, (!string.IsNullOrEmpty(user.UserName) && !string.IsNullOrEmpty(user.UserName)) ? (user.FirstName + " " + user.LastName) : ""),
new Claim(JwtClaimTypes.GivenName, user.FirstName ?? ""),
new Claim(JwtClaimTypes.FamilyName, user.LastName ?? ""),
new Claim(JwtClaimTypes.Email, user.Email ?? ""),
};
if (roles != null && roles.Count > 0)
{
foreach (var role in roles)
{
claims.Add(new Claim(ClaimsIdentity.DefaultRoleClaimType, role));
claims.Add(new Claim(JwtClaimTypes.Role, role));
claims.Add(new Claim(ClaimTypes.Role, role));
}
}
return(claims.ToArray());
}
public string GenerateJwtToken(string email, ApplicationIdentityUser user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddDays(Convert.ToDouble(_appSettings["JwtExpireDays"]));
var token = new JwtSecurityToken(
_appSettings["JwtIssuer"],
_appSettings["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
ApplicationIdentityUser 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 https://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));
}
public async Task <IActionResult> DownloadFileStream(Models.FileModel fileModel)
{
if (System.IO.File.Exists(fileModel.Path))
{
FileStream sourceStream = new FileStream(fileModel.Path, FileMode.Open, FileAccess.Read, System.IO.FileShare.Read, BufferSize, FileOptions.Asynchronous | FileOptions.SequentialScan);
ThrottledStream destinationStreamStream = null;
ApplicationIdentityUser user = null;
if (HttpContext.User != null)
{
user = await _userManager.GetUserAsync(HttpContext.User);
if (user != null)
{
destinationStreamStream = new ThrottledStream(sourceStream, kbpsLogged);
}
}
if (destinationStreamStream == null)
{
destinationStreamStream = new ThrottledStream(sourceStream, kbps);
}
await LoggerDownload(user, fileModel);
FileStreamResult fileStreamResult = new FileStreamResult(destinationStreamStream, FindMimeHelpers.GetMimeFromFile(fileModel.Path));
fileStreamResult.FileDownloadName = fileModel.TrustedName;
fileStreamResult.LastModified = fileModel.UploadDT;
return(fileStreamResult);
}
else
{
ModelState.AddModelError("Error", $"The request couldn't be processed (Error 0).");
return(NotFound(ModelState));
}
}
public ActionResult Register(RegisterViewModel newUser, bool isHost = false)
{
if (!ModelState.IsValid)
{
return(View(newUser));
}
IdentityResult result = accountAppService.Register(newUser, isHost, User.IsInRole("Admin"));
if (result.Succeeded)
{
ApplicationIdentityUser registeredUser = accountAppService.Find(newUser.UserName, newUser.PasswordHash);
if (User.IsInRole("Admin"))
{
accountAppService.AssignToRole(registeredUser.Id, "Admin");
}
else
{
if (isHost)
{
accountAppService.AssignToRole(registeredUser.Id, "Host");
}
else
{
accountAppService.AssignToRole(registeredUser.Id, "User");
ShoppingCartAppService.Insert(registeredUser.Id);
}
}
return(RedirectToAction("Login"));
}
else
{
ModelState.AddModelError("", result.Errors.FirstOrDefault());
return(View(newUser));
}
}
public async Task <Int32> InitPlayerAsync(ApplicationIdentityUser user)
{
int AspNetUserId = user.Id;
SqlParameter[] @params =
{
new SqlParameter("@returnVal", SqlDbType.Int)
{
Direction = ParameterDirection.Output
},
new SqlParameter("@AspNetUserId", SqlDbType.Int)
{
Direction = ParameterDirection.Input,Value = AspNetUserId
},
};
await context.Database.ExecuteSqlRawAsync("EXEC @returnVal=[dbo].[InitializeNewRegistrationPlayer] @AspNetUserId", @params);
int result = Convert.ToInt32(@params[0].Value);
await Task.FromResult(result);
return(result);
}
public ApplicationIdentityUser Find(string username, string password)
{
ApplicationIdentityUser result = manager.Find(username, password);
return(result);
}
public async Task <ActionResult <ResultData> > AddUser([FromBody] UserAddDto userDto)
{
if (userDto.UserName == null || userDto.Password == null)
{
return(BadRequest());
}
{
var user = await _userManager.FindByNameAsync(userDto.UserName);
if (user != null)
{
return(new ResultData(ReturnCode.Error, -1, "用户已存在", null));
}
string today = DateTime.Now.ToString("yyyyMMdd");
var lastTeacher = _teacherRepository
.LoadEntities(o => o.TeacherId.ToString().StartsWith(today))
.LastOrDefault();
int teacherId;
if (lastTeacher == null)
{
teacherId = Convert.ToInt32(today + "00");
}
else
{
string lastTwoChar = lastTeacher.TeacherId.ToString().Substring(lastTeacher.TeacherId.ToString().Length - 2, 2);
int index = Convert.ToInt32(lastTwoChar.StartsWith("0") ? lastTwoChar.Substring(1, 1) : lastTwoChar);
if (index < 99)
{
index++;
if (index.ToString().Length == 1)
{
teacherId = Convert.ToInt32(today + "0" + index.ToString());
}
else
{
teacherId = Convert.ToInt32(today + index.ToString());
}
}
else
{
return(new ResultData(ReturnCode.Error, -1, "每天只能添加100个用户", null));
}
}
user = new ApplicationIdentityUser
{
UserName = userDto.UserName,
Teacher = new Teacher
{
TeacherId = teacherId,
}
};
var result = await _userManager.CreateAsync(user, userDto.Password);
if (result.Succeeded)
{
return(new ResultData(ReturnCode.Succeed, -1, "添加成功", teacherId));
}
return(new ResultData(ReturnCode.Error, -1, "添加失败", null));
}
}
public void ShoppingCartSetup()
{
accountAppService = new AccountAppService();
shoppingCartAppService = new ShoppingCartAppService();
user = accountAppService.Find("TestUser", "TestUser");
}
public static AppUser CopyApplicationIdentityUserProperties(this AppUser appUser, ApplicationIdentityUser applicationIdentityUser)
{
if (appUser == null)
{
return(null);
}
if (applicationIdentityUser == null)
{
return(null);
}
appUser.UserName = applicationIdentityUser.UserName;
appUser.Id = applicationIdentityUser.Id;
appUser.AccessFailedCount = applicationIdentityUser.AccessFailedCount;
appUser.Email = applicationIdentityUser.Email;
appUser.EmailConfirmed = applicationIdentityUser.EmailConfirmed;
appUser.LockoutEnabled = applicationIdentityUser.LockoutEnabled;
appUser.LockoutEndDateUtc = applicationIdentityUser.LockoutEndDateUtc;
appUser.PasswordHash = applicationIdentityUser.PasswordHash;
appUser.PhoneNumber = applicationIdentityUser.PhoneNumber;
appUser.PhoneNumberConfirmed = applicationIdentityUser.PhoneNumberConfirmed;
appUser.SecurityStamp = applicationIdentityUser.SecurityStamp;
appUser.TwoFactorEnabled = applicationIdentityUser.TwoFactorEnabled;
foreach (var claim in applicationIdentityUser.Claims)
{
appUser.Claims.Add(new ApplicationUserClaim
{
ClaimType = claim.ClaimType,
ClaimValue = claim.ClaimValue,
Id = claim.Id,
UserId = claim.UserId
});
}
foreach (var role in applicationIdentityUser.Roles)
{
appUser.Roles.Add(role.ToApplicationUserRole());
}
foreach (var login in applicationIdentityUser.Logins)
{
appUser.Logins.Add(new ApplicationUserLogin
{
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
UserId = login.UserId
});
}
return(appUser);
}
//Create [email protected] with password=Admin@123456 in the Admin role public void InitializeIdentityForEF(AspnetIdentityWithOnionContext db) { // This is only for testing purpose const string name = "*****@*****.**"; const string password = "******"; string[] roleName = new string[] { "Admin", "Anonim", "Manager", "User" }; var applicationRoleManager = IdentityFactory.CreateRoleManager(db); var applicationUserManager = IdentityFactory.CreateUserManager(db); //Create Role Admin if it does not exist ApplicationIdentityRole role; foreach (var item in roleName) { role = new ApplicationIdentityRole { Name = item }; applicationRoleManager.Create(role); role = null; } //var role = applicationRoleManager.FindByName(roleName); //if (role == null) //{ // role = new ApplicationIdentityRole { Name = roleName }; // applicationRoleManager.Create(role); //} var user = applicationUserManager.FindByName(name); if (user == null) { user = new ApplicationIdentityUser { UserName = name, Email = name }; applicationUserManager.Create(user, password); applicationUserManager.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = applicationUserManager.GetRoles(user.Id); foreach (var item in roleName) { if (!rolesForUser.Contains(item)) { applicationUserManager.AddToRole(user.Id, item); } } var context = new AspnetIdentityWithOnionContext("name=AppContext", new DebugLogger()); //var image = new Image { Path = "http://lorempixel.com/400/200/" }; //context.Set<Image>().Add(image); //context.Set<Category>().Add(new Category { Name = "Cameras", IsActive = true, Path = "6a81942d-d825-4c18-97ca-4a5a906c68ad.jpg" }); //context.Set<Category>().Add(new Category { Name = "BagsCase", IsActive = true, Path = "49307dd0-7ada-4e12-b1e9-e5040269288f.jpg" }); //context.Set<Category>().Add(new Category { Name = "Accessuare", IsActive = true, Path = "1c68860a-3b9a-4278-90ce-0b0237ec4898.jpg" }); //context.Set<SubCategory>().Add(new SubCategory { Name = "SLR Cameras", }) //for (var i = 0; i < 10; i++) //{ // context.Set<Product>().Add(new Product { Name = "My Product", Price = 35}); //} //context.Set<Category>().Add(new Category { Name = "ForExample", IsActive = true }); //context.SaveChanges(); }
private IList <Claim> SetClaims(ApplicationIdentityUser user, TokenType tokenType)
{
throw new NotImplementedException();
}
public async Task <ActionResult> Users_Create([DataSourceRequest] DataSourceRequest request, ApplicationIdentityUser user)
{
if (ModelState.IsValid)
{
var user_created = await _userManager.CreateAsync(user);
if (user_created.Succeeded)
{
return(Json(new[] { user }.ToDataSourceResult(request, ModelState)));
}
}
return(null);
}
private async Task <Models.FileModel> SaveInDb(string remoteIpAddress, string fileNameFinaliy, string fileNameForDisplay, string fileNameForFileStorage, long contentType, string mimeType)
{
var ipInfo = await new IpDataServlet(remoteIpAddress).GetIpInfo();
var fileUploaded = new FileModel
{
CreationDateTime = DateTime.UtcNow,
Id = Guid.NewGuid(),
Size = contentType,
Name = fileNameForDisplay,
StorageName = fileNameForFileStorage,
Type = mimeType,
Hash = CreateHashFile(fileNameForDisplay, fileNameForFileStorage, remoteIpAddress, contentType),
Asn = ipInfo.Asn,
AsnDomain = ipInfo.AsnDomain,
AsnName = ipInfo.AsnName,
AsnRoute = ipInfo.AsnRoute,
AsnType = ipInfo.AsnType,
CallingCode = ipInfo.CallingCode,
City = ipInfo.City,
ContinentCode = ipInfo.ContinentCode,
ContinentName = ipInfo.ContinentName,
CountryCode = ipInfo.CountryCode,
CountryName = ipInfo.CountryName,
Ip = ipInfo.Ip,
Latitude = ipInfo.Latitude,
Longitude = ipInfo.Longitude,
Organisation = ipInfo.Organisation,
Postal = ipInfo.Postal,
Region = ipInfo.Region,
RegionCode = ipInfo.RegionCode,
TimeZone = ipInfo.TimeZone,
Languages = ipInfo.Languages
};
try
{
if (mimeType == "application/octet-stream" || string.IsNullOrEmpty(mimeType))
{
mimeType = FindMimeHelpers.GetMimeFromFile(fileNameFinaliy);
}
if (mimeType == "application/octet-stream" || string.IsNullOrEmpty(mimeType))
{
if (FindMimeHelpers.ListOfMimeType == null || FindMimeHelpers.ListOfMimeType.Count <= 0)
{
FindMimeHelpers.ListOfMimeType = _context.PermittedExtension
.Select(x => new { x.Extension, x.Description })
.ToDictionary(x => x.Extension, x => x.Description);
}
fileUploaded.Type = FindMimeHelpers.GetMimeFromExtensions(Path.GetExtension(fileNameForDisplay).ToLowerInvariant());
}
}
catch (Exception ex)
{
_logger.LogError("Erro para recuperar o MineType : " + ex.Message);
if (FindMimeHelpers.ListOfMimeType == null || FindMimeHelpers.ListOfMimeType.Count <= 0)
{
FindMimeHelpers.ListOfMimeType = _context.PermittedExtension
.Select(x => new { x.Extension, x.Description })
.ToDictionary(x => x.Extension, x => x.Description);
}
fileUploaded.Type = FindMimeHelpers.GetMimeFromExtensions(Path.GetExtension(fileNameForDisplay).ToLowerInvariant());
}
if (string.IsNullOrEmpty(fileUploaded.Type))
{
fileUploaded.Type = "application/octet-stream";
}
//Salvar no Banco de Dados
await _context.Files.AddAsync(fileUploaded);
await _context.SaveChangesAsync();
ApplicationIdentityUser user = null;
try
{
if (HttpContext.User != null)
{
user = await _userManager.GetUserAsync(HttpContext.User);
if (user != null)
{
await _context.FilesUsers.AddAsync(new FileUserModel
{
Id = Guid.NewGuid(),
FileId = fileUploaded.Id,
UserId = user.Id,
CreationDateTime = DateTime.Now
});
await _context.SaveChangesAsync();
}
}
}
catch (Exception ex)
{
_logger.LogError($"Erro para associar o arquivo {fileUploaded.Id} ao usuário {user?.Id} - {ex}");
}
return(new Models.FileModel
{
Hash = fileUploaded.Hash,
Id = fileUploaded.Id,
Size = fileUploaded.Size,
UntrustedName = fileUploaded.Name,
UploadDT = fileUploaded.CreationDateTime
});
}
public static void Initialise(IServiceProvider serviceProvider)
{
using (IServiceScope scope = serviceProvider.CreateScope())
{
ApplicationIdentityDbContext applicationIdentityDbContext =
scope.ServiceProvider.GetRequiredService <ApplicationIdentityDbContext>();
ApplicationDbContext applicationDbContext =
scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
applicationDbContext.Database.Migrate();
applicationIdentityDbContext.Database.Migrate();
UserManager <ApplicationIdentityUser> userManager =
scope.ServiceProvider
.GetRequiredService <UserManager <ApplicationIdentityUser> >();
ApplicationIdentityUser identityUser = userManager
.FindByEmailAsync("*****@*****.**")
.GetAwaiter()
.GetResult();
if (identityUser == null)
{
identityUser = new ApplicationIdentityUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Jane",
LastName = "Doe"
};
IdentityResult result = userManager
.CreateAsync(identityUser, "P@ssw0rd")
.GetAwaiter()
.GetResult();
if (result.Succeeded)
{
IMapper mapper = scope.ServiceProvider.GetRequiredService <IMapper>();
User user = mapper.Map <User>(identityUser);
user.Id = new Guid("25320c5e-f58a-4b1f-b63a-8ee07a840bdf");
user.PhoneBooks = new List <PhoneBook>
{
new PhoneBook
{
Id = new Guid("c7ba6add-09c4-45f8-8dd0-eaca221e5d93"),
Title = "The Family",
Description = "This phone book contains the contact details for my family",
PhoneBookEntries = new List <PhoneBookEntry>
{
new PhoneBookEntry
{
Id = new Guid("a3749477-f823-4124-aa4a-fc9ad5e79cd6"),
FirstName = "Jack",
LastName = "Tenrec",
PhoneNumber = "+27219038278",
EmailAddress = "*****@*****.**",
Address = "8 Zebra Close, Kuils River"
},
new PhoneBookEntry
{
Id = new Guid("70a1f9b9-0a37-4c1a-99b1-c7709fc64167"),
FirstName = "Hannah",
LastName = "Dundee",
PhoneNumber = "+27219038279",
EmailAddress = "*****@*****.**",
Address = "13 Skyvue Drive, Kuils River"
},
new PhoneBookEntry
{
Id = new Guid("60188a2b-2784-4fc4-8df8-8919ff838b0b"),
FirstName = "Mess",
LastName = "O",
PhoneNumber = "+27219038280",
EmailAddress = "*****@*****.**",
Address = "221 Main Road, West Bank"
},
new PhoneBookEntry
{
Id = new Guid("76053df4-6687-4353-8937-b45556748abe"),
FirstName = "Mustapha",
LastName = "P",
PhoneNumber = "+27219038281",
EmailAddress = "*****@*****.**",
Address = "54 Robert Street, Blackheath"
},
new PhoneBookEntry
{
Id = new Guid("447eb762-95e9-4c31-95e1-b20053fbe215"),
FirstName = "Ginzo",
LastName = "Ninja",
PhoneNumber = "+27219038282",
EmailAddress = "*****@*****.**",
Address = "19 Fernkloof Crescent, West Bank"
}
}
}
};
applicationDbContext.Users.Add(user);
applicationDbContext.SaveChanges();
}
}
}
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new ApplicationIdentityUser {
UserName = Input.Email, Email = Input.Email
};
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Name))
{
user.ContactName = info.Principal.FindFirstValue(ClaimTypes.Name);
}
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public void SeedAdmin(UserManager <ApplicationIdentityUser> userManager)
{
// ADD SUPERUSER
if (userManager.FindByEmailAsync(SuperAdminUserName).Result == null)
{
ApplicationIdentityUser user = new ApplicationIdentityUser();
user.UserName = SuperAdminUserName;
user.Email = SuperAdminUserName;
user.ContactName = "Super Admin User";
user.EmailConfirmed = true;
IdentityResult result = userManager.CreateAsync(user, SuperAdminPassword).Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, RoleType.SuperAdmin.ToString()).Wait();
}
}
// ADD ADMINUSER
if (userManager.FindByEmailAsync(AdminUserName).Result == null)
{
ApplicationIdentityUser user = new ApplicationIdentityUser();
user.UserName = AdminUserName;
user.Email = AdminUserName;
user.ContactName = "Admin User";
user.EmailConfirmed = true;
IdentityResult result = userManager.CreateAsync(user, AdminPassword).Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, RoleType.Admin.ToString()).Wait();
}
}
// ADD RESTIDENT
if (userManager.FindByEmailAsync(ResidentUserName).Result == null)
{
ApplicationIdentityUser user = new ApplicationIdentityUser();
user.UserName = ResidentUserName;
user.Email = ResidentUserName;
user.ContactName = "Resident User";
user.EmailConfirmed = true;
IdentityResult result = userManager.CreateAsync(user, ResidentPassword).Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, RoleType.Resident.ToString()).Wait();
}
}
// ADD READONLYUSER (has access to all non personal info but can't edit anything)
if (userManager.FindByEmailAsync(ReadOnlyUserName).Result == null)
{
ApplicationIdentityUser user = new ApplicationIdentityUser();
user.UserName = ReadOnlyUserName;
user.Email = ReadOnlyUserName;
user.ContactName = "Read Only User";
user.EmailConfirmed = true;
IdentityResult result = userManager.CreateAsync(user, ReadOnlyPassword).Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(user, RoleType.ReadOnlyUser.ToString()).Wait();
}
}
}
protected override void Seed(DAL.ApplicationDBContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data. E.g.
//
// context.People.AddOrUpdate(
// p => p.FullName,
// new Person { FullName = "Andrew Peters" },
// new Person { FullName = "Brice Lambson" },
// new Person { FullName = "Rowan Miller" }
// );
//
ApplicationRoleManager roleManager = new ApplicationRoleManager(context);
roleManager.Create(new IdentityRole("Admin"));
roleManager.Create(new IdentityRole("User"));
roleManager.Create(new IdentityRole("Host"));
ApplicationUserManager manager = new ApplicationUserManager(context);
var admin = manager.Find("admin", "admin");
if (admin == null)
{
ApplicationIdentityUser user =
new ApplicationIdentityUser()
{
UserName = "******",
PasswordHash = "admin",
};
user.PasswordHash = manager.PasswordHasher.HashPassword(user.PasswordHash);
manager.Create(user);
manager.AddToRole(user.Id, "Admin");
}
//User For Unit Testing
var testUser = manager.Find("TestUser", "TestUser");
if (testUser == null)
{
ApplicationIdentityUser user =
new ApplicationIdentityUser()
{
UserName = "******",
PasswordHash = "TestUser",
};
user.PasswordHash = manager.PasswordHasher.HashPassword(user.PasswordHash);
manager.Create(user);
manager.AddToRole(user.Id, "User");
ApplicationIdentityUser registeredUser = manager.Find("TestUser", "TestUser");
context.ClientUsers.Add(new User.ClientUser {
Id = registeredUser.Id
});
context.ShoppingCarts.Add(new ShoppingCart {
ClientId = registeredUser.Id
});
context.SaveChanges();
}
//Host For Unit Testing
var testHost = manager.Find("TestHost", "TestHost");
if (testHost == null)
{
ApplicationIdentityUser user =
new ApplicationIdentityUser()
{
UserName = "******",
PasswordHash = "TestHost",
};
user.PasswordHash = manager.PasswordHasher.HashPassword(user.PasswordHash);
manager.Create(user);
manager.AddToRole(user.Id, "Host");
ApplicationIdentityUser registeredUser = manager.Find("TestHost", "TestHost");
context.HostUsers.Add(new User.HostUser {
Id = registeredUser.Id
});
context.SaveChanges();
}
//AccountAppService accountAppService = new AccountAppService();
//shoppingCartAppService = new ShoppingCartAppService();
//RegisterViewModel newUser = new RegisterViewModel
//{
// UserName = "******",
// Email = "*****@*****.**",
// PasswordHash = "123456",
// ConfirmPassword = "******",
// age = Enum_Age.Under16,
// SSN = "123456789"
//};
//IdentityResult result = accountAppService.Register(newUser, false, false);
//ApplicationIdentityUser registeredUser = accountAppService.Find(newUser.UserName, newUser.PasswordHash);
//accountAppService.AssignToRole(registeredUser.Id, "User");
//shoppingCartAppService.Insert(registeredUser.Id);
}
public ArticleViewModel()
{
Author = new ApplicationIdentityUser();
}
public IdentityResult Register(ApplicationIdentityUser user)
{
IdentityResult result = manager.Create(user, user.PasswordHash);
return(result);
}
public AddArticleViewModel()
{
Author = new ApplicationIdentityUser();
CategoryViews = new List <CategoryViewModel>();
}
private async Task <ApplicationIdentityUser> AutoProvisionUserAsync(string provider, string providerUserId, IEnumerable <Claim> claims)
{
// create a list of claims that we want to transfer into our store
var filtered = new List <Claim>();
// user's display name
var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (name != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, name));
}
else
{
var first = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName)?.Value;
var last = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Surname)?.Value;
if (first != null && last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
}
else if (first != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first));
}
else if (last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, last));
}
}
// email
var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != null)
{
filtered.Add(new Claim(JwtClaimTypes.Email, email));
}
var user = new ApplicationIdentityUser
{
UserName = Guid.NewGuid().ToString(),
};
var identityResult = await _userManager.CreateAsync(user);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
if (filtered.Any())
{
identityResult = await _userManager.AddClaimsAsync(user, filtered);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
}
identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
return(user);
}
public async Task <ActionResult> Users_Update([DataSourceRequest] DataSourceRequest request, ApplicationIdentityUser user)
{
if (ModelState.IsValid)
{
var finduser = await _userManager.FindByIdAsync(user.Id.ToString());
finduser.FirstName = user.FirstName;
finduser.LastName = user.LastName;
finduser.Address = user.Address;
finduser.Email = user.Email;
finduser.AccessFailedCount = finduser.AccessFailedCount;
finduser.ConcurrencyStamp = finduser.ConcurrencyStamp;
finduser.EmailConfirmed = finduser.EmailConfirmed;
finduser.LockoutEnabled = finduser.LockoutEnabled;
finduser.LockoutEnd = finduser.LockoutEnd;
finduser.NormalizedEmail = finduser.NormalizedEmail;
finduser.NormalizedUserName = finduser.NormalizedUserName;
finduser.PasswordHash = finduser.PasswordHash;
finduser.PhoneNumber = finduser.PasswordHash;
finduser.PhoneNumberConfirmed = finduser.PhoneNumberConfirmed;
finduser.SecurityStamp = finduser.SecurityStamp;
finduser.TwoFactorEnabled = finduser.TwoFactorEnabled;
finduser.UserName = user.UserName;
var user_created = await _userManager.UpdateAsync(finduser);
return(Json(new[] { finduser }.ToDataSourceResult(request, ModelState)));
}
return(null);
}
