public async Task<ActionResult> Create([Bind(Include = "ID,Name,Visibility")] Game game)
{
if (ModelState.IsValid)
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this.db));
var appUser = await manager.FindByIdAsync(this.User.Identity.GetUserId());
db.Games.Add(game);
await manager.AddClaimAsync(appUser.Id, new Claim("GameMembership", game.ID.ToString()));
await manager.AddClaimAsync(appUser.Id, new Claim("GameOwnership", game.ID.ToString()));
await manager.AddClaimAsync(appUser.Id, new Claim("GameMaster", game.ID.ToString()));
var membership = new GameMembership()
{
Game = game,
ApplicationUser = appUser,
Roles = "Owner",
};
db.GameMemberships.Add(membership);
await db.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(game);
}
public async Task GetUserClaimTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var user = new IdentityUser("u1");
var result = await manager.CreateAsync(user);
UnitTestHelper.IsSuccess(result);
Assert.NotNull(user);
var claims = new[]
{
new Claim("c1", "v1"),
new Claim("c2", "v2"),
new Claim("c3", "v3")
};
foreach (Claim c in claims)
{
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var userClaims = new List<Claim>(await manager.GetClaimsAsync(user.Id));
Assert.Equal(3, userClaims.Count);
foreach (Claim c in claims)
{
Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
}
}
public async Task ClaimsIdentityTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var role = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
var user = new IdentityUser("Hao");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Admin")));
UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Local")));
UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Admin"));
UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Local"));
Claim[] userClaims =
{
new Claim("Whatever", "Value"),
new Claim("Whatever2", "Value2")
};
foreach (var c in userClaims)
{
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var identity = await manager.CreateIdentityAsync(user, "test");
var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory<IdentityUser, string>;
Assert.NotNull(claimsFactory);
var claims = identity.Claims;
Assert.NotNull(claims);
Assert.True(
claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName));
Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id));
Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin"));
Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local"));
Assert.True(
claims.Any(
c =>
c.Type == ClaimsIdentityFactory<IdentityUser>.IdentityProviderClaimType &&
c.Value == ClaimsIdentityFactory<IdentityUser>.DefaultIdentityProviderClaimValue));
foreach (var cl in userClaims)
{
Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));
}
}
public async Task<int> SyncMembershipsAndClaims([FromBody]Fixit fixit)
{
var userName = fixit.UserName;
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this.db));
var query = db.GameMemberships.Include(mem => mem.Game).Include(mem => mem.ApplicationUser);
if (!string.IsNullOrEmpty(userName) && !userName.Equals("$all", StringComparison.InvariantCultureIgnoreCase))
{
query = query.Where(mem => mem.ApplicationUser.DisplayName == userName);
}
var memberships = await query.ToListAsync();
int membershipsFixed = 0;
foreach (var membershipGroup in memberships.GroupBy(m => m.ApplicationUser))
{
var user = membershipGroup.Key;
var claims = await manager.GetClaimsAsync(user.Id);
foreach (var membership in membershipGroup)
{
bool wasFixed = false;
if (!claims.Where(c => c.Type == "GameMembership").Any(c => c.Value == membership.GameID.ToString()))
{
var result = await manager.AddClaimAsync(user.Id, new Claim("GameMembership", membership.GameID.ToString()));
if (!result.Succeeded)
{
Trace.WriteLine(string.Format("Error creating GameMembership claim for user {0} for game {1}: errors {2}", user.Id, membership.GameID,
string.Join(", ", result.Errors)));
}
else
{
wasFixed = true;
}
}
if (membership.Roles.Contains("Owner"))
{
if (!claims.Where(c => c.Type == "GameOwnership").Any(c => c.Value == membership.GameID.ToString()))
{
var result = await manager.AddClaimAsync(user.Id, new Claim("GameOwnership", membership.GameID.ToString()));
if (!result.Succeeded)
{
Trace.WriteLine(string.Format("Error creating GameOwnership claim for user {0} for game {1}: errors {2}", user.Id, membership.GameID,
string.Join(", ", result.Errors)));
}
else
{
wasFixed = true;
}
}
}
if (membership.Roles.Contains("Gamemaster"))
{
if (!claims.Where(c => c.Type == "GameMaster").Any(c => c.Value == membership.GameID.ToString()))
{
var result = await manager.AddClaimAsync(user.Id, new Claim("GameMaster", membership.GameID.ToString()));
if (!result.Succeeded)
{
Trace.WriteLine(string.Format("Error creating GameMaster claim for user {0} for game {1}: errors {2}", user.Id, membership.GameID,
string.Join(", ", result.Errors)));
}
else
{
wasFixed = true;
}
}
}
if (wasFixed)
{
membershipsFixed++;
}
}
}
return membershipsFixed;
}
public async Task OnPostCreateLogins()
{
//var info = await _signInManager.GetExternalLoginInfoAsync();
if (!await _roleManager.RoleExistsAsync("BasicUser"))
{
await _roleManager.CreateAsync(new IdentityRole("BasicUser"));
}
if (!await _roleManager.RoleExistsAsync("Admin"))
{
await _roleManager.CreateAsync(new IdentityRole("Admin"));
}
if (!await _roleManager.RoleExistsAsync("Superadmin"))
{
await _roleManager.CreateAsync(new IdentityRole("Superadmin"));
}
var user = await _userManager.FindByNameAsync("*****@*****.**");
//var result = await _userManager.CreateAsync(user);
//var result = await _userManager.AddLoginAsync(user, info);
if (user == null)
{
ApplicationUser au = new ApplicationUser()
{
UserName = "******", Email = "*****@*****.**"
};
var result = await _userManager.CreateAsync(au, "abCD$$123");
user = await _userManager.FindByNameAsync("*****@*****.**");
}
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, "BasicUser");
result = await _userManager.AddToRoleAsync(user, "Admin");
result = await _userManager.AddToRoleAsync(user, "Superadmin");
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_EndDate", "01/01/2070"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_EndDate", "01/01/2070"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Superadmin_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Superadmin_EndDate", "01/01/2070"));
}
user = await _userManager.FindByNameAsync("*****@*****.**");
if (user == null)
{
ApplicationUser au = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
};
var result = await _userManager.CreateAsync(au, "abCD$$123");
user = await _userManager.FindByNameAsync("*****@*****.**");
}
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, "BasicUser");
result = await _userManager.AddToRoleAsync(user, "Admin");
result = await _userManager.AddToRoleAsync(user, "Superadmin");
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_EndDate", "01/01/2070"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_EndDate", "01/01/2070"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Superadmin_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Superadmin_EndDate", "01/01/2070"));
}
user = await _userManager.FindByNameAsync("*****@*****.**");
if (user == null)
{
ApplicationUser au = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
};
var result = await _userManager.CreateAsync(au, "abCD$$123");
user = await _userManager.FindByNameAsync("*****@*****.**");
}
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, "BasicUser");
result = await _userManager.AddToRoleAsync(user, "Admin");
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_EndDate", "01/01/2070"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin_EndDate", "01/01/2070"));
}
user = await _userManager.FindByNameAsync("*****@*****.**");
if (user == null)
{
ApplicationUser au = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
};
var result = await _userManager.CreateAsync(au, "abCD$$123");
user = await _userManager.FindByNameAsync("*****@*****.**");
}
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, "BasicUser");
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_StartDate", "01/01/2000"));
result = await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("BasicUser_EndDate", "01/01/2070"));
}
//----------------------------------------------------------
_context.Database.ExecuteSqlRaw("TRUNCATE TABLE NavBarMenuItems");
#region Parent Items
int menuItemOrder = 0;
NavBarMenuItem mmMyInfo = new NavBarMenuItem()
{
MenuDisplayName = "My Info",
ParentMenuId = 0,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmMyInfo);
_context.SaveChanges();
NavBarMenuItem mmAdmin = new NavBarMenuItem()
{
MenuDisplayName = "Admin",
ParentMenuId = 0,
UserPolicy = "AdminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmAdmin);
_context.SaveChanges();
NavBarMenuItem mmSuperadmin = new NavBarMenuItem()
{
MenuDisplayName = "Superadmin",
ParentMenuId = 0,
UserPolicy = "SuperadminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmSuperadmin);
_context.SaveChanges();
#endregion
#region First Level Items
menuItemOrder = 0;
NavBarMenuItem mmBasicSubItem1 = new NavBarMenuItem()
{
MenuDisplayName = "BasicSubItem1",
ParentMenuId = mmMyInfo.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmBasicSubItem1);
_context.SaveChanges();
NavBarMenuItem mmBasicSubItem2 = new NavBarMenuItem()
{
MenuDisplayName = "BasicSubItem2",
ParentMenuId = mmMyInfo.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmBasicSubItem2);
_context.SaveChanges();
NavBarMenuItem mmBasicSubItem3 = new NavBarMenuItem()
{
MenuDisplayName = "BasicSubItem3",
ParentMenuId = mmMyInfo.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mmBasicSubItem3);
_context.SaveChanges();
//Admin
menuItemOrder = 0;
NavBarMenuItem mm = new NavBarMenuItem()
{
MenuDisplayName = "AdminSubItem1",
ParentMenuId = mmAdmin.MenuId,
UserPolicy = "AdminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "AdminSubItem2",
ParentMenuId = mmAdmin.MenuId,
UserPolicy = "AdminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "AdminSubItem3",
ParentMenuId = mmAdmin.MenuId,
UserPolicy = "AdminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
//Superadmin
menuItemOrder = 0;
mm = new NavBarMenuItem()
{
MenuDisplayName = "SuperadminSubItem1",
ParentMenuId = mmSuperadmin.MenuId,
UserPolicy = "SuperadminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "SuperadminSubItem2",
ParentMenuId = mmSuperadmin.MenuId,
UserPolicy = "SuperadminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "SuperadminSubItem3",
ParentMenuId = mmSuperadmin.MenuId,
UserPolicy = "SuperadminPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
#endregion
#region Second Level Items
menuItemOrder = 0;
mm = new NavBarMenuItem()
{
MenuDisplayName = "BasicSub-SubItem1",
ParentMenuId = mmBasicSubItem1.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "BasicSub-SubItem2",
ParentMenuId = mmBasicSubItem1.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "BasicSub-SubItem3",
ParentMenuId = mmBasicSubItem1.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
mm = new NavBarMenuItem()
{
MenuDisplayName = "BasicSub-SubItem1",
ParentMenuId = mmBasicSubItem1.MenuId,
UserPolicy = "BasicUserPolicy",
MenuURL = "",
CreatedDate = DateTime.Now,
ItemOrder = menuItemOrder++
};
_context.NavBarMenuItems.Add(mm);
_context.SaveChanges();
#endregion
int iii = 0;
}
public async Task<GameResult> Create([FromBody]GameResult result)
{
if (result == null)
{
throw new ArgumentNullException("game");
}
GameVisibility visibility;
if (!Enum.TryParse(result.Visibility, out visibility))
{
throw new ArgumentException("game.Visibility is not valid");
}
var game = new Game()
{
Name = result.Name,
Visibility = visibility,
};
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this.db));
var appUser = await manager.FindByIdAsync(this.User.Identity.GetUserId());
db.Games.Add(game);
await manager.AddClaimAsync(appUser.Id, new Claim("GameMembership", game.ID.ToString()));
await manager.AddClaimAsync(appUser.Id, new Claim("GameOwnership", game.ID.ToString()));
await manager.AddClaimAsync(appUser.Id, new Claim("GameMaster", game.ID.ToString()));
var membership = new GameMembership()
{
Game = game,
ApplicationUser = appUser,
Roles = "Owner",
};
db.GameMemberships.Add(membership);
await db.SaveChangesAsync();
result.GameId = game.ID;
return result;
}
public void Initialize()
{
_userDbContext.Database.Migrate();
_configurationDbContext.Database.Migrate();
_persistedGrantDbContext.Database.Migrate();
_configurationDbContext.Database.BeginTransaction();
try
{
if (!_userDbContext.Roles.Any(x => x.Name == "admin"))
{
var role = new IdentityRole("admin");
var result = _roleManager.CreateAsync(role).Result;
if (!result.Succeeded)
{
throw new Exception($"Ошибка добавления роли: {role.Name}");
}
}
if (!_userDbContext.Users.Any(x => x.UserName == "admin"))
{
var user = _userManager.FindByNameAsync("admin").Result;
if (user == null)
{
user = new Account()
{
UserName = "******",
Email = "*****@*****.**"
};
var userResult = _userManager.CreateAsync(user, "qwerty").Result;
if (!userResult.Succeeded)
{
throw new Exception($"Ошибка добавления пользователя: {user.UserName}");
}
}
if (!_userManager.IsInRoleAsync(user, "admin").Result)
{
var roleResult = _userManager.AddToRoleAsync(user, "admin").Result;
if (!roleResult.Succeeded)
{
throw new Exception($"Ошибка добавления пользователя {user.UserName} в роль admin");
}
}
var claims = new Claim[]
{
new Claim(JwtClaimTypes.NickName, "admin_nick"),
new Claim(JwtClaimTypes.Role, "admin"),
new Claim(JwtClaimTypes.Email, "*****@*****.**")
};
var userClaims = _userManager.GetClaimsAsync(user).Result;
var claimsForAdd = claims.Except(userClaims);
foreach (var claim in claimsForAdd)
{
var claimResult = _userManager.AddClaimAsync(user, claim).Result;
if (!claimResult.Succeeded)
{
throw new Exception($"Ошбка добавления клейма {claim.Type} поьзователю {user.UserName}");
}
}
}
foreach (var identityResource in _config.GetIdentityResources())
{
if (!_configurationDbContext.IdentityResources.Any(x => x.Name == identityResource.Name))
{
_configurationDbContext.IdentityResources.Add(identityResource.ToEntity());
}
}
_configurationDbContext.SaveChanges();
foreach (var apiResource in _config.GetApiResources())
{
if (!_configurationDbContext.ApiResources.Any(x => x.Name == apiResource.Name))
{
_configurationDbContext.ApiResources.Add(apiResource.ToEntity());
}
}
_configurationDbContext.SaveChanges();
foreach (var client in _config.GetClients())
{
if (!_configurationDbContext.Clients.Any(x => x.ClientId == client.ClientId))
{
_configurationDbContext.Clients.Add(client.ToEntity());
}
}
_configurationDbContext.SaveChanges();
}
catch
{
_configurationDbContext.Database.RollbackTransaction();
throw;
}
_configurationDbContext.Database.CommitTransaction();
}
public async Task <bool> AddRoleAsync(ApplicationUser user, string roleName)
{
return((await userManager
.AddClaimAsync(user, new Claim(Policies.RoleClaimTypeValue, roleName)))
.Succeeded);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapRazorPages();
});
using IServiceScope scope = app.ApplicationServices.CreateScope();
IServiceProvider scopeServiceProvider = scope.ServiceProvider;
ApplicationDbContext context = scopeServiceProvider.GetRequiredService <ApplicationDbContext>();
if (context != null && context.Database.GetPendingMigrations().Any())
{
context.Database.Migrate();
if (!context.Users.Any())
{
const string defaultAdminUserName = "******";
const string defaultAdminPassword = "******";
UserManager <User> userManager = scopeServiceProvider.GetRequiredService <UserManager <User> >();
RoleManager <Role> roleManager = scopeServiceProvider.GetRequiredService <RoleManager <Role> >();
User admin = userManager.FindByNameAsync(Configuration[defaultAdminUserName]).GetAwaiter().GetResult();
if (admin == null)
{
Role adminRoleName = new Role {
Name = "admin"
};
Role userRoleName = new Role {
Name = "user"
};
roleManager.CreateAsync(adminRoleName).GetAwaiter().GetResult();
roleManager.CreateAsync(userRoleName).GetAwaiter().GetResult();
admin = new User {
UserName = Configuration[defaultAdminUserName], Email = Configuration[defaultAdminUserName], FirstName = "مدیر", LastName = "سایت", EmailConfirmed = true, LockoutEnabled = false
};
IdentityResult identityResult = userManager.CreateAsync(admin, Configuration[defaultAdminPassword]).GetAwaiter().GetResult();
userManager.AddToRoleAsync(admin, "admin").GetAwaiter().GetResult();
userManager.AddToRoleAsync(admin, "user").GetAwaiter().GetResult();
Claim adminClaimName = new Claim(ClaimTypes.Role, "admin");
userManager.AddClaimAsync(admin, adminClaimName).GetAwaiter().GetResult();
roleManager.AddClaimAsync(adminRoleName, adminClaimName).GetAwaiter().GetResult();
}
}
}
}
public async Task <IActionResult> OnPostConfirmationAsync(string?returnUrl = null)
{
returnUrl ??= Url.Content("~/authentication/login");
// 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 }));
}
string?normalizedDisplayName = Input.DisplayName?.ToUpper();
if (await _context.Profiles.FirstOrDefaultAsync(x => x.NormalizedDisplayName == normalizedDisplayName) != null)
{
ModelState.AddModelError(string.Empty, "Display name is already taken.");
}
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
if (error.Code != "DuplicateUserName")
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(Page());
}
await _userManager.AddClaimAsync(user, new Claim("display_name", Input.DisplayName));
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
// 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);
var userId = await _userManager.GetUserIdAsync(user);
var profile = new Profile
{
DisplayName = Input.DisplayName,
NormalizedDisplayName = normalizedDisplayName,
Id = user.Id,
IsVerified = false,
};
await _userManager.AddClaimAsync(user, new Claim("is_verified", "false"));
_context.Profiles.Add(profile);
_context.SaveChanges();
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>.");
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
private async Task InBuildUserAsync()
{
RegistrationViewModel model = new RegistrationViewModel
{
FirstName = "Dev",
MiddleName = "Vikram",
LastName = "Sharma",
Email = "*****@*****.**",
Password = "******",
Department = 0,
Grade = 0,
HQ = 0,
Pancard = "Dummy",
DOJ = DateTime.Now,
DOB = DateTime.Now,
Desigination = 0,
CustomUserName = "******",
PasswordRaw = "dev@123",
IsEnabled = true
};
string userName = model.FirstName.Substring(0, 1).ToLower() + model.MiddleName.Substring(0, 1).ToLower() + model.LastName.Replace(" ", "").ToLower();
int iUserNameCount = _appDbContext.Users.Where(u => u.UserName.Contains(userName)).ToList().Count();
if (iUserNameCount > 0)
{
iUserNameCount += 1;
userName += iUserNameCount.ToString();
}
model.CustomUserName = userName;
model.PasswordRaw = model.Password;
var userIdentity = _mapper.Map <AppUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
var user = await _userManager.FindByIdAsync(userIdentity.Id);
#region "Create User, Roles & Add Role Claims"
//User: Data in Roles Table
var accountManagerRole = await _roleManager.FindByNameAsync(Permissions.Roles.USER);
if (accountManagerRole == null)
{
accountManagerRole = new IdentityRole(Permissions.Roles.USER);
await _roleManager.CreateAsync(accountManagerRole);
}
////Add UserClaims
//await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Admins.CRUD));
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Delete));
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));
//await _roleManager.AddClaimAsync(accountManagerRole, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));
//await _roleManager.AddClaimAsync(accountManagerRole, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));
//await _roleManager.AddClaimAsync(accountManagerRole, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));
if (!await _userManager.IsInRoleAsync(user, accountManagerRole.Name))
{
await _userManager.AddToRoleAsync(user, accountManagerRole.Name);
}
#endregion
//if (!result.Succeeded) return new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState));
//Extra Tables
ContactResourseViewModel contact = new ContactResourseViewModel
{
ID = Guid.NewGuid().ToString(),
RefTableId = user.Id,
RefTableName = Constants.ReferenceTableNames.EMPLOYEE,
Address = "Dev User Address",
State = "Dev User State",
City = "Dev User City",
PinCode = "400086",
MobileNumber = "9029718964",
ResidenceNumber = "9090909090"
};
var contactData = _mapper.Map <ContactResourseViewModel, Data.ContactResourse>(contact);
_appDbContext.ContactResourse.Add(contactData);
await _appDbContext.SaveChangesAsync();
}
public async Task Seed()
{
// create the database contexts and apply any pending migrations
if (_context.Database.GetPendingMigrations().Any())
{
_context.Database.Migrate();
}
if (_identityServerConfigContext.Database.GetPendingMigrations().Any())
{
_identityServerConfigContext.Database.Migrate();
}
if (_identityServerPersistedGrantContext.Database.GetPendingMigrations().Any())
{
_identityServerPersistedGrantContext.Database.Migrate();
}
if ((await _roleManager.FindByNameAsync("AdminUserClassicRole")) == null)
{
var addedRole = new DbRole {
Name = "AdminUserClassicRole", Description = "classic style admin role"
};
var addRoleResult = await _roleManager.CreateAsync(addedRole);
if (addRoleResult.Succeeded)
{
await _roleManager.AddClaimAsync(addedRole, new Claim(ClaimTypes.Role, "AdminUSerClassicRoleClaim"));
}
}
string emailUsername = "******";
DbUser user = await _userManager.FindByNameAsync(emailUsername);
if (user == null)
{
var result = await _userManager.CreateAsync(new DbUser
{
UserName = emailUsername,
DateOfBirth = new DateTime(1970, 1, 1),
Email = emailUsername,
Firstname = "test",
LockoutEnabled = true,
Surname = "user",
EmailConfirmed = true,
TwoFactorEnabled = false
}, "Pa$$word1");
if (result.Succeeded)
{
user = await _userManager.FindByNameAsync(emailUsername);
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, MusicStoreConstants.Roles.AdminUser));
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, MusicStoreConstants.Roles.TestUser));
await _userManager.AddClaimAsync(user, new Claim(MusicStoreConstants.CLaimTypes.MusicStoreApiReadAccess, "true"));
await _userManager.AddClaimAsync(user, new Claim(MusicStoreConstants.CLaimTypes.MusicStoreApiWriteAccess, "true"));
var addRoleResult = await _userManager.AddToRoleAsync(user, "AdminUserClassicRole");
}
else
{
_logger.LogError("Error adding user - error: " + string.Join(", ", result.Errors.Select(e => e.Description)));
}
}
if (!_identityServerConfigContext.Clients.Any())
{
IdentityServerConfigUrls urls = new IdentityServerConfigUrls()
{
AngularAppClientUri = "https://localhost:44350",
MvcClientUri = "https://localhost:44357"
};
string angularClientUrl = this._configuration.GetValue <string>("AngularAppClientUrl");
if (!string.IsNullOrWhiteSpace(angularClientUrl))
{
urls.AngularAppClientUri = angularClientUrl;
}
// set url for the server side mvc app "/samples/oauthtest"
string mvcAppClientUrl = this._configuration.GetValue <string>("MvcAppClientUrl");
if (!string.IsNullOrWhiteSpace(mvcAppClientUrl))
{
urls.MvcClientUri = mvcAppClientUrl;
}
foreach (var client in IdentityServerClients.GetClients(urls))
{
_identityServerConfigContext.Clients.Add(client.ToEntity());
}
_identityServerConfigContext.SaveChanges();
}
if (!_identityServerConfigContext.IdentityResources.Any())
{
foreach (var resource in IdentityServerResources.GetIdentityResources())
{
_identityServerConfigContext.IdentityResources.Add(resource.ToEntity());
}
_identityServerConfigContext.SaveChanges();
}
if (!_identityServerConfigContext.ApiResources.Any())
{
foreach (var resource in IdentityServerResources.GetApiResources())
{
_identityServerConfigContext.ApiResources.Add(resource.ToEntity());
}
_identityServerConfigContext.SaveChanges();
}
ContentCreator contentCreator = new ContentCreator(_context);
if (await _context.AlbumGroups.CountAsync() == 0)
{
//create default groups
await _context.AlbumGroups.AddAsync(new DbAlbumGroup
{
Key = "FEATURED_ALBUMS",
Name = "Featured albums",
CreatedUtc = DateTime.UtcNow,
UpdatedUtc = DateTime.UtcNow
});
await _context.AlbumGroups.AddAsync(new DbAlbumGroup
{
Key = "NEW_ALBUMS",
Name = "New albums",
CreatedUtc = DateTime.UtcNow,
UpdatedUtc = DateTime.UtcNow
});
await _context.AlbumGroups.AddAsync(new DbAlbumGroup
{
Key = "BESTSELLING_ALBUMS",
Name = "Bestselling albums",
CreatedUtc = DateTime.UtcNow,
UpdatedUtc = DateTime.UtcNow
});
await _context.SaveChangesAsync();
}
if (await _context.Genres.CountAsync() == 0)
{
await contentCreator.CreateGenres("Rock", "Pop", "Indie", "Funk", "Grunge", "Electronic", "Punk", "Alternative");
}
if (await _context.Artists.CountAsync() == 0)
{
await contentCreator.CreateSeedContent();
}
}
public async Task <bool> UpdateUserAsync(UserDTO user)
{
//check the user on null before go on
if (user == null)
{
return(false);
}
var dbUser = await _dbContext.Users
.FirstOrDefaultAsync(u => u.Id == user.Id);
//TODO: validate user.Email
if (dbUser == null)
{
return(false);
}
if (String.IsNullOrEmpty(user.Email))
{
return(false);
}
dbUser.Email = user.Email;
if (user.Token != null && user.Token.Token != null && user.Token.Token.Length > 0)
{
// Add token to the user in the database
dbUser.Token = user.Token.Token;
dbUser.TokenExpires = user.Token.TokenExpires;
var newTokenClaim = new Claim(ClaimType.Token, user.Token.Token);
var newTokenExpires = new Claim(ClaimType.TokenExpires,
user.Token.TokenExpires.ToString("yyyy-MM-dd hh:mm:ss"));
var userClaims = await _userManager.GetClaimsAsync(dbUser);
var currentTokenClaim = userClaims.SingleOrDefault(
c => c.Type.Equals(ClaimType.Token));
var currentTokenClaimExpires = userClaims.SingleOrDefault(
c => c.Type.Equals(ClaimType.TokenExpires));
if (currentTokenClaim == null)
{
await _userManager.AddClaimAsync(dbUser, newTokenClaim);
}
else
{
await _userManager.ReplaceClaimAsync(dbUser, currentTokenClaim, newTokenClaim);
}
if (currentTokenClaimExpires == null)
{
await _userManager.AddClaimAsync(dbUser, newTokenExpires);
}
else
{
await _userManager.ReplaceClaimAsync(dbUser, currentTokenClaimExpires, newTokenExpires);
}
}
var isAdmin = await _userManager.IsInRoleAsync(dbUser, Roles.Admin);
var adminClaim = new Claim(Roles.Admin, "true");
if (isAdmin && !user.IsAdmin)
{ // Remove Admin role
await _userManager.RemoveFromRoleAsync(dbUser, Roles.Admin);
//Remove Admin claim
await _userManager.RemoveClaimAsync(dbUser, adminClaim);
}
else if (!isAdmin && user.IsAdmin)
{ // Add Admin role
await _userManager.AddToRoleAsync(dbUser, Roles.Admin);
// Add Admin claim
await _userManager.AddClaimAsync(dbUser, adminClaim);
}
var result = await _dbContext.SaveChangesAsync();
return(result >= 0); // if result is 0 then anyway we return true
}
public static async Task SeedUserAsync(UserManager <AppUser> userManager, RoleManager <AppRole> roleManager)
{
if (!userManager.Users.Any())
{
var users = new List <AppUser>
{
new AppUser
{
DisplayName = "Normal",
Email = "*****@*****.**",
UserName = "******",
IsPayroll = true,
Address = new Address
{
FirstName = "Normal",
LastName = "Client",
Building = "ICT",
Room = "2A",
}
},
new AppUser
{
DisplayName = "Admin",
Email = "*****@*****.**",
UserName = "******",
IsPayroll = true
},
new AppUser
{
DisplayName = "NY Pizza",
Email = "*****@*****.**",
UserName = "******",
IsPayroll = true
},
new AppUser
{
DisplayName = "Burger King",
Email = "*****@*****.**",
UserName = "******",
IsPayroll = true
},
new AppUser
{
DisplayName = "McDonalds",
Email = "*****@*****.**",
UserName = "******",
IsPayroll = true
}
};
var roles = new List <AppRole>
{
new AppRole {
Name = "Admin"
},
new AppRole {
Name = "Manager"
},
new AppRole {
Name = "Member"
}
};
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, "Ny Pizza"),
new Claim(ClaimTypes.Name, "Burger King"),
new Claim(ClaimTypes.Name, "McDonalds"),
};
foreach (var role in roles)
{
await roleManager.CreateAsync(role);
}
foreach (var user in users)
{
await userManager.CreateAsync(user, "Pa$$w0rd");
await userManager.AddToRoleAsync(user, "Member");
if (user.Email == "*****@*****.**")
{
await userManager.AddToRoleAsync(user, "Admin");
}
if (user.Email == "*****@*****.**")
{
await userManager.AddToRoleAsync(user, "Manager");
}
if (user.Email == "*****@*****.**")
{
await userManager.AddToRoleAsync(user, "Manager");
}
if (user.Email == "*****@*****.**")
{
await userManager.AddToRoleAsync(user, "Manager");
}
if (user.Email == "*****@*****.**")
{
await userManager.AddToRoleAsync(user, "Manager");
}
if (user.Email == "*****@*****.**")
{
await userManager.AddClaimAsync(user, claims.FirstOrDefault(x => x.Value == "Ny Pizza"));
}
if (user.Email == "*****@*****.**")
{
await userManager.AddClaimAsync(user, claims.FirstOrDefault(x => x.Value == "Burger King"));
}
if (user.Email == "*****@*****.**")
{
await userManager.AddClaimAsync(user, claims.FirstOrDefault(x => x.Value == "McDonalds"));
}
}
}
}
/// <summary>
/// Generate default admin user / role
/// </summary>
private static async Task EnsureSeedIdentityData <TUser, TRole>(UserManager <TUser> userManager,
RoleManager <TRole> roleManager, IdentityData identityDataConfiguration)
where TUser : IdentityUser, new()
where TRole : IdentityRole, new()
{
// adding roles from seed
foreach (var r in identityDataConfiguration.Roles)
{
if (!await roleManager.RoleExistsAsync(r.Name))
{
var role = new TRole
{
Name = r.Name
};
var result = await roleManager.CreateAsync(role);
if (result.Succeeded)
{
foreach (var claim in r.Claims)
{
await roleManager.AddClaimAsync(role, new System.Security.Claims.Claim(claim.Type, claim.Value));
}
}
}
}
// adding users from seed
foreach (var user in identityDataConfiguration.Users)
{
var identityUser = new TUser
{
UserName = user.Username,
Email = user.Email,
EmailConfirmed = true
};
var userByUserName = await userManager.FindByNameAsync(user.Username);
var userByEmail = await userManager.FindByEmailAsync(user.Email);
// User is already exists in database
if (userByUserName != default || userByEmail != default)
{
continue;
}
// if there is no password we create user without password
// user can reset password later, because accounts have EmailConfirmed set to true
var result = !string.IsNullOrEmpty(user.Password)
? await userManager.CreateAsync(identityUser, user.Password)
: await userManager.CreateAsync(identityUser);
if (result.Succeeded)
{
foreach (var claim in user.Claims)
{
await userManager.AddClaimAsync(identityUser, new System.Security.Claims.Claim(claim.Type, claim.Value));
}
foreach (var role in user.Roles)
{
await userManager.AddToRoleAsync(identityUser, role);
}
}
}
}
public async Task <IdentityResult> AddClaimAsync(AppUser userIdentity, string roleName) => await _userManager.AddClaimAsync(userIdentity, new Claim(ClaimTypes.Role, roleName));
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 IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.GivenName))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst(ClaimTypes.GivenName));
}
if (info.Principal.HasClaim(c => c.Type == Claims.City))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst(Claims.City));
}
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.StateOrProvince))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst(ClaimTypes.StateOrProvince));
}
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Country))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst(ClaimTypes.Country));
}
if (info.ProviderKey != null)
{
await _userManager.AddClaimAsync(user,
new Claim("stravaId", info.ProviderKey));
}
// Include the access token in the properties
var props = new AuthenticationProperties();
props.StoreTokens(info.AuthenticationTokens);
props.IsPersistent = true;
//await _signInManager.SignInAsync(user, isPersistent: false);
await _signInManager.SignInAsync(user, props, info.LoginProvider);
_logger.LogInformation("User created an account using {Name} provider.", 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 static void Initialize(DbContext context, UserManager <User> userManager)
{
context.Database.EnsureCreated();
#region Add Employees
if (!context.Set <Employee>().Any())
{
context.Set <Employee>().Add(new Employee()
{
FirstName = "Александр", SecondName = "Москвин", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 1, ManagerId = 10
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Ольга", SecondName = "Калатуша", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 1, ManagerId = 10
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Антон", SecondName = "Сапановский", Mail = "*****@*****.**", MaxRole = RoleType.Administrator, Rate = 1, ManagerId = 10, Leaves = new List <Leave>
{
new Leave()
{
StartDate = new DateTime(2019, 8, 22), EndDate = new DateTime(2019, 9, 9), TypeLeave = TypeLeave.Vacation
}
}
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Анна", SecondName = "Степакова", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 0.5, ManagerId = 10, Leaves = new List <Leave>
{
new Leave()
{
StartDate = new DateTime(2019, 9, 5), EndDate = new DateTime(2019, 9, 9), TypeLeave = TypeLeave.Training
},
new Leave()
{
StartDate = new DateTime(2019, 9, 11), EndDate = new DateTime(2019, 9, 14), TypeLeave = TypeLeave.Idle
}
}
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Дмитрий", SecondName = "Павлов", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 0.75, ManagerId = 10, Leaves = new List <Leave>
{
new Leave()
{
StartDate = new DateTime(2019, 9, 3), EndDate = new DateTime(2019, 9, 11), TypeLeave = TypeLeave.Idle
}
}
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Ольга", SecondName = "Гуляева", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 1, ManagerId = 10
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Павел", SecondName = "Костин", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 1, ManagerId = 10
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Михаил", SecondName = "Ворожба", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 1.25, ManagerId = 10
});
context.Set <Employee>().Add(new Employee()
{
FirstName = "Юлия", SecondName = "Ильиных", Mail = "*****@*****.**", MaxRole = RoleType.Employee, Rate = 0.5, ManagerId = 10
});
context.Set <Employee>().Add(new Employee {
FirstName = "Татьяна", SecondName = "Елисеева", Mail = "*****@*****.**", MaxRole = RoleType.Manager, Rate = 1.25, ManagerId = null
});
context.SaveChanges();
foreach (var employee in context.Set <Employee>())
{
var user = new User
{
UserName = employee.Mail,
Email = employee.Mail,
EmployeeId = employee.Id
};
var result = userManager.CreateAsync(user, employee.Mail + "Password1").Result;
//Retrieves the name of the constant in the specified enumeration that has the specified value.
var role = Enum.GetName(typeof(RoleType), employee.MaxRole);
var resultAddRole = userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, role)).Result;
if (!(result.Succeeded && resultAddRole.Succeeded))
{
throw new ApplicationException("ERROR_INITIALIZE_DB");
}
}
}
#endregion
#region Add Projects
if (!context.Set <Project>().Any())
{
context.Set <Project>().Add(new Project()
{
Name = "LTRegistrator Frontend"
});
context.Set <Project>().Add(new Project()
{
Name = "LTRegistrator Backend"
});
context.SaveChanges();
}
#endregion
#region Add ProjectEmployees
if (!context.Set <ProjectEmployee>().Any())
{
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 10, Role = RoleType.Manager
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 10, Role = RoleType.Manager
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 2, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 4, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 5, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 6, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 1, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 3, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 1, EmployeeId = 3, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 7, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 8, Role = RoleType.Employee
});
context.Set <ProjectEmployee>().Add(new ProjectEmployee()
{
ProjectId = 2, EmployeeId = 9, Role = RoleType.Employee
});
context.SaveChanges();
}
#endregion
#region Add Tasks
if (!context.Set <Task>().Any())
{
context.Set <Task>().Add(new Task()
{
ProjectId = 2, EmployeeId = 1, Name = "LTRegistrator Backend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 1, EmployeeId = 2, Name = "LTRegistrator Frontend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 2, EmployeeId = 3, Name = "LTRegistrator Backend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 1, EmployeeId = 3, Name = "LTRegistrator Frontend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 1, EmployeeId = 4, Name = "LTRegistrator Frontend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 1, EmployeeId = 5, Name = "LTRegistrator Frontend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 1, EmployeeId = 6, Name = "LTRegistrator Frontend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 2, EmployeeId = 7, Name = "LTRegistrator Backend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 2, EmployeeId = 8, Name = "LTRegistrator Backend"
});
context.Set <Task>().Add(new Task()
{
ProjectId = 2, EmployeeId = 9, Name = "LTRegistrator Backend"
});
context.SaveChanges();
}
#endregion
#region Add TaskNotes
if (!context.Set <TaskNote>().Any())
{
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 4, Day = new DateTime(2019, 9, 1)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 2, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 8, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 8, Day = new DateTime(2019, 9, 6)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 8, Day = new DateTime(2019, 9, 12)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 1, Hours = 10, Day = new DateTime(2019, 9, 14)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 10, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 8, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 4, Day = new DateTime(2019, 9, 6)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 6, Day = new DateTime(2019, 9, 7)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 5, Day = new DateTime(2019, 9, 10)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 11, Day = new DateTime(2019, 9, 13)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 2, Hours = 2, Day = new DateTime(2019, 9, 14)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 3, Hours = 5, Day = new DateTime(2019, 9, 11)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 3, Hours = 1, Day = new DateTime(2019, 9, 12)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 3, Hours = 10, Day = new DateTime(2019, 9, 13)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 3, Hours = 12, Day = new DateTime(2019, 9, 10)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 4, Hours = 12, Day = new DateTime(2019, 9, 12)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 4, Hours = 12, Day = new DateTime(2019, 9, 13)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 4, Hours = 12, Day = new DateTime(2019, 9, 14)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 5, Hours = 6, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 5, Hours = 8, Day = new DateTime(2019, 9, 3)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 5, Hours = 7, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 5, Hours = 13, Day = new DateTime(2019, 9, 10)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 5, Hours = 4, Day = new DateTime(2019, 9, 15)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 6, Hours = 10, Day = new DateTime(2019, 9, 1)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 6, Hours = 12, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 6, Hours = 14, Day = new DateTime(2019, 9, 12)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 6, Hours = 18, Day = new DateTime(2019, 9, 13)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 6, Hours = 10, Day = new DateTime(2019, 9, 14)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 1)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 3)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 5)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 6)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 7)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 8)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 7, Hours = 8, Day = new DateTime(2019, 9, 9)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 2, Day = new DateTime(2019, 9, 1)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 4, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 6, Day = new DateTime(2019, 9, 5)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 4, Day = new DateTime(2019, 9, 7)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 3, Day = new DateTime(2019, 9, 9)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 8, Hours = 12, Day = new DateTime(2019, 9, 10)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 9, Hours = 12, Day = new DateTime(2019, 9, 5)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 9, Hours = 6, Day = new DateTime(2019, 9, 7)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 9, Hours = 7, Day = new DateTime(2019, 9, 8)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 9, Hours = 1, Day = new DateTime(2019, 9, 9)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 9, Hours = 12, Day = new DateTime(2019, 9, 10)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 8, Day = new DateTime(2019, 9, 1)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 8, Day = new DateTime(2019, 9, 2)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 8, Day = new DateTime(2019, 9, 3)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 8, Day = new DateTime(2019, 9, 4)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 6, Day = new DateTime(2019, 9, 5)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 6, Day = new DateTime(2019, 9, 6)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 6, Day = new DateTime(2019, 9, 7)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 2, Day = new DateTime(2019, 9, 8)
});
context.Set <TaskNote>().Add(new TaskNote()
{
TaskId = 10, Hours = 1, Day = new DateTime(2019, 9, 9)
});
context.SaveChanges();
}
#endregion
}
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 ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
EmailConfirmed = true,
FullName = info.Principal.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name")?.Value
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
// If they exist, add claims to the user for:
// Given(first) name
// Locale
// Picture
if (info.Principal.HasClaim(c => c.Type == "urn:google:picture"))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst("urn:google:picture"));
}
if (info.Principal.HasClaim(c => c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name"))
{
await _userManager.AddClaimAsync(user,
info.Principal.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name"));
}
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.NameIdentifier))
{
await _userManager.AddClaimAsync(user, new Claim("OAuthNameIdentifier",
info.Principal.FindFirst(ClaimTypes.NameIdentifier)?.Value));
}
// Include the access token in the properties
var props = new AuthenticationProperties();
props.StoreTokens(info.AuthenticationTokens);
props.IsPersistent = true;
await _signInManager.SignInAsync(user, isPersistent : true);
var PhoneNumber = user.PhoneNumber != null;
Response.Cookies.Append("_FN", user.FullName?.Split(" ")[0], new CookieOptions()
{
Path = "/",
HttpOnly = true
});
Response.Cookies.Append("_PN", PhoneNumber.ToString(), new CookieOptions()
{
Path = "/",
HttpOnly = true
});
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
async public Task <IActionResult> SeedUsers()
{
var allUsers = userManager.Users.ToList();
foreach (var x in allUsers)
{
await userManager.DeleteAsync(x);
}
ApplicationUser adam = new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
};
ApplicationUser viktor = new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
};
ApplicationUser susan = new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
};
ApplicationUser peter = new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
};
ApplicationUser xerxes = new ApplicationUser {
UserName = "******", Email = "*****@*****.**"
};
await userManager.CreateAsync(adam);
await userManager.AddClaimAsync(adam, new System.Security.Claims.Claim("role", "administrator"));
await userManager.CreateAsync(viktor);
await userManager.AddClaimAsync(viktor, new System.Security.Claims.Claim("role", "subscriber"));
await userManager.AddClaimAsync(viktor, new System.Security.Claims.Claim("age", "15"));
await userManager.CreateAsync(susan);
await userManager.AddClaimAsync(susan, new System.Security.Claims.Claim("role", "subscriber"));
await userManager.AddClaimAsync(susan, new System.Security.Claims.Claim("age", "48"));
await userManager.CreateAsync(peter);
await userManager.AddClaimAsync(peter, new System.Security.Claims.Claim("role", "publisher"));
await userManager.CreateAsync(xerxes);
//await userManager.AddClaimAsync(xerxes, new System.Security.Claims.Claim("role", "administrator"));
//List<ApplicationUser> userList = new List<ApplicationUser>()
//{
// new ApplicationUser {UserName="******", Email="*****@*****.**"},
// new ApplicationUser {UserName="******", Email="*****@*****.**"},
// new ApplicationUser {UserName="******", Email="*****@*****.**"},
// new ApplicationUser {UserName="******", Email="*****@*****.**"},
// new ApplicationUser {UserName="******", Email="*****@*****.**"}
//};
//foreach (ApplicationUser applicationUser in userList)
//{
// await userManager.CreateAsync(applicationUser);
//}
// Skapa användare med userManager...
return(Ok());
/*
* foreach (ApplicationUser applicationUser in databaseContext.Users)
* {
* databaseContext.Remove(applicationUser);
* }
*
* List<ApplicationUser> userList = new List<ApplicationUser>()
* {
* new ApplicationUser {UserName="******", Email="*****@*****.**"},
* new ApplicationUser {UserName="******", Email="*****@*****.**"},
* new ApplicationUser {UserName="******", Email="*****@*****.**"},
* new ApplicationUser {UserName="******", Email="*****@*****.**"},
* new ApplicationUser {UserName="******", Email="*****@*****.**"}
* };
* foreach (ApplicationUser applicationUser in userList)
* {
* databaseContext.Add(applicationUser);
* }
* databaseContext.SaveChanges();
* return Ok("hej");
*/
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
/**************************************************************************************************/
/*CUSTOM HOTEL CLAIMS USERS SHOULD BE ASSIGNED UPON RESGISTER - THESE CLAIMS ARE FOR ADMIN TO EDIT*/
var serverClaim = new Claim(HotelClaims.Server, HotelClaims.False);
await _userManager.AddClaimAsync(user, serverClaim);
var cookClaim = new Claim(HotelClaims.Cook, HotelClaims.False);
await _userManager.AddClaimAsync(user, cookClaim);
var receptionistClaim = new Claim(HotelClaims.Receptionist, HotelClaims.False);
await _userManager.AddClaimAsync(user, receptionistClaim);
/**************************************************************************************************/
/**************************************************************************************************/
_logger.LogInformation("User created a new account with password.");
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 = 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>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
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 <IActionResult> CreateAsync([FromBody] UserViewModel userViewModel)
{
if (ModelState.IsValid)
{
try
{
var user = new CustomIdentityUser
{
FirstName = userViewModel.UserDto.FirstName,
LastName = userViewModel.UserDto.LastName,
UserName = userViewModel.UserDto.Email,
Email = userViewModel.UserDto.Email,
AccountId = Guid.NewGuid(),
IsEnabled = true
};
var result = await userManager.CreateAsync(user, userViewModel.Password).ConfigureAwait(false);
if (result.Succeeded)
{
var selectedRoles = userViewModel.UserRoles.Where(p => p.Selected).Select(p => p.RoleName).ToList();
await userManager.AddToRolesAsync(user, selectedRoles);
await userManager.AddClaimAsync(user, new System.Security.Claims.Claim("FullName", string.Format("{0} {1}", userViewModel.UserDto.FirstName, userViewModel.UserDto.LastName)));
await userManager.AddClaimAsync(user, new System.Security.Claims.Claim("AccountId", user.AccountId.ToString()));
var currentUser = await userManager.GetUserAsync(HttpContext.User);
var userDto = new Helpdesk.Service.Dto.ApplicationUserDto()
{
CreatedUser = currentUser.FirstName + " " + currentUser.LastName,
ModifiedUser = currentUser.FirstName + " " + currentUser.LastName,
CreateDate = DateTime.Now,
ModifyDate = DateTime.Now,
FirstName = userViewModel.UserDto.FirstName,
LastName = userViewModel.UserDto.LastName,
TrIdentityNumber = userViewModel.UserDto.TrIdentityNumber,
Title = userViewModel.UserDto.Title,
Email = userViewModel.UserDto.Email,
MobileNumber = userViewModel.UserDto.MobileNumber,
AccountId = user.AccountId,
Address = new Helpdesk.Model.Entities.Address(),
RecordStatus = Helpdesk.Model.Enums.RecordStatus.A
};
var userId = applicationUserService.Create(userDto);
if (userViewModel.Companies == null)
{
return(Ok());
}
if (userViewModel.Companies.Count > 0)
{
companyAgentMappingService.Create(userViewModel.Companies, userId);
}
return(Ok());
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(BadRequest(ModelState));
}
catch (Exception)
{
throw;
}
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> Post(IFormFile file)
{
if (file == null)
{
return(BadRequest("File is null"));
}
if (file.Length == 0)
{
return(BadRequest("File is empty"));
}
if (file.Length > 10 * 1024 * 1024)
{
return(BadRequest("File size cannot exceed 10M"));
}
var acceptTypes = new[] { ".jpg", ".jpeg", ".png" };
if (acceptTypes.All(t => t != Path.GetExtension(file.FileName).ToLower()))
{
return(BadRequest("File type not valid, only jpg and png are acceptable."));
}
if (string.IsNullOrWhiteSpace(_hostingEnvironment.WebRootPath))
{
_hostingEnvironment.WebRootPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
}
var uploadsFolderPath = Path.Combine(_hostingEnvironment.WebRootPath, "avatars");
if (!Directory.Exists(uploadsFolderPath))
{
Directory.CreateDirectory(uploadsFolderPath);
}
var userName = GetClaimValue(JwtClaimTypes.PreferredUserName);
var fileName = $"{userName}.jpg";
var filePath = Path.Combine(uploadsFolderPath, fileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
//await file.CopyToAsync(stream);
var imageStream = file.OpenReadStream();
using (var image = Image.Load(imageStream, out _))
{
image.Mutate(c => c.Resize(100, 100));
image.SaveAsJpeg(stream);
}
}
var user = await _userManager.FindByNameAsync(userName);
var pictureClaims = User.Claims.Where(x => x.Type == JwtClaimTypes.Picture).ToList();
if (pictureClaims.Any())
{
await _userManager.RemoveClaimsAsync(user, pictureClaims);
}
var result = await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Picture, fileName));
if (!result.Succeeded)
{
throw new Exception(result.Errors.First().Description);
}
ViewData["picture"] = fileName;
return(View("Index"));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/Identity/Account/Confirm");
if (ModelState.IsValid)
{
var role = new IdentityRole();
if (!this.context.AppUsers.Any())
{
role.Name = "Admin";
}
else
{
role.Name = "User";
}
bool x = await _roleManager.RoleExistsAsync(role.Name);
if (!x)
{
await _roleManager.CreateAsync(role);
}
var address = new Address {
City = Input.City, Country = Input.Country, PostalCode = Input.Postal, Street = Input.Street
};
var user = new ApplicationUser {
Email = Input.Email, PhoneNumber = Input.PhoneNumber, UserName = Input.Username, FullName = Input.FullName, Address = address, Gender = Input.Gender, Role = role
};
var result = await _userManager.CreateAsync(user, Input.Password);
await _userManager.AddToRoleAsync(user, role.Name);
await _userManager.AddClaimAsync(user, claim : new Claim(ClaimTypes.Role.ToString(), role.Name));
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
//this.context.UserRoles.Add(new IdentityUserRole<string> { RoleId = role.Id, UserId = user.Id });
//this.context.SaveChanges();
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 <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível" }));
}
var userEF = await _userManager.FindByEmailAsync(model.Email);
if (userEF != null && !string.IsNullOrEmpty(userEF.Email))
{
return(Response_BadRequest("Já existe usuário cadastrado com o email informado."));
}
if (model.FuncionarioId <= 0 && model.ProfissionalId <= 0)
{
return(Response_BadRequest("O ID do funcionário ou o ID do profisssional deve ser informado."));
}
if (model.FuncionarioId > 0 && model.ProfissionalId > 0)
{
return(Response_BadRequest("O ID do funcionário e o ID do profisssional não podem ser informados ao mesmo tempo."));
}
if (!ModelState.IsValid)
{
NotifyErrorInvalidModel();
return(Response());
}
userEF = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(userEF, model.Senha);
if (result.Succeeded)
{
await _userManager.AddClaimAsync(userEF, new Claim("Tipos", "Ler"));
try
{
var registerCommand = new RegisterAppUserCommand(Guid.Parse(userEF.Id), userEF.Email);
await _mediator.SendCommand(registerCommand);
if (!InvalidOperation())
{
await _userManager.DeleteAsync(userEF);
return(Response(model));
}
var usuarioCore_Api = _appUserRepository.GetById(Guid.Parse(userEF.Id));
if (usuarioCore_Api == null || usuarioCore_Api.Id != Guid.Parse(userEF.Id))
{
await _userManager.DeleteAsync(userEF);
throw new Exception("Couldn't create the user.");
}
_logger.LogInformation(1, "Sucess!");
var response = new { Message = "Sucess!", NovoUserID = userEF.Id };
return(Response(response));
}
catch (Exception exc1)
{
_appUserRepository.Remove(Guid.Parse(userEF.Id));
await _userManager.DeleteAsync(userEF);
var response = new { Message = "Couldn't create the user: " + exc1.Message };
//_bugsnag.Notify(new Exception(exc1.Message));
return(Response(response));
}
}
AddIdentityErrors(result);
return(Response(model));
}
public static async Task Initialize(ApplicationDbContext context, UserManager <ApplicationUser> userManager, RoleManager <IdentityRole> roleManager)
{
context.Database.Migrate();
string AdminUserName = "******";
var AdminUser = await userManager.FindByNameAsync(AdminUserName);
if (AdminUser == null)
{
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
Name = "Ilnur",
Surname = "Safin",
JobTitle = "Administrator",
Stations = "GYD",
PhoneNumber = "+994502531012"
};
var result = await userManager.CreateAsync(user, "gu48u6y");
if (result.Succeeded)
{
var AdminRole = await roleManager.FindByNameAsync("Admin");
if (AdminRole == null)
{
// first we create Admin rool
var role = new IdentityRole
{
Name = "Admin"
};
await roleManager.CreateAsync(role);
await roleManager.AddClaimAsync(AdminRole, new Claim("Manage Users", "manage.users"));
await userManager.AddClaimAsync(user, new Claim("Manage Users", "manage.users"));
await userManager.AddToRoleAsync(user, "Admin");
}
else
{
await roleManager.AddClaimAsync(AdminRole, new Claim("Manage Users", "manage.users"));
await userManager.AddClaimAsync(user, new Claim("Manage Users", "manage.users"));
await userManager.AddToRoleAsync(user, "Admin");
}
}
}
var OperationsRole = await roleManager.FindByNameAsync("Operations");
if (OperationsRole == null)
{
// first we create Admin rool
var role = new IdentityRole
{
Name = "Operations"
};
await roleManager.CreateAsync(role);
}
var StationRole = await roleManager.FindByNameAsync("Station");
if (StationRole == null)
{
// first we create Admin rool
var role = new IdentityRole
{
Name = "Station"
};
await roleManager.CreateAsync(role);
}
}
private async Task ClaimAdd()
{
var user = await userManager.FindByNameAsync("a");
var res = await userManager.AddClaimAsync(user, new Claim("MyClaim", "abc"));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
IsIndependance = Input.IsIndependance,
IsGarde = Input.IsGarde,
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
// Add the right role to that user:
//await _userManager.AddToRoleAsync(user, Input.SelectedRole);
await _userManager.AddToRoleAsync(user, "Musician");
// Creating LibUser when IdentityUser is created
var instruments = Instruments.Where(x => x.IsSelected == true).ToList();
var instrumentsIds = instruments.Select(x => x.Id).ToList();
var libUser = new LibUserTO {
IdentityUserId = user.Id, InstrumentIds = instrumentsIds
};
var done = _libraryUnitOfWork.LibUserRepository.Add(libUser);
_logger.LogInformation("User created a new account with password.");
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 = user.Id, code = code, returnUrl = returnUrl },
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 (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _userManager.AddClaimAsync(user, new Claim("FirstName", user.FirstName));
await _userManager.AddClaimAsync(user, new Claim("LastName", user.LastName));
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 DupeUserClaimTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var user = new IdentityUser("u1");
var result = await manager.CreateAsync(user);
Assert.NotNull(user);
var claims = new[]
{
new Claim("c1", "v1"),
new Claim("c2", "v2"),
new Claim("c3", "v3")
};
foreach (Claim c in claims)
{
// Add dupes
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var userClaims = new List<Claim>(await manager.GetClaimsAsync(user.Id));
Assert.Equal(6, userClaims.Count);
var currentExpected = 6;
foreach (Claim c in claims)
{
Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, c));
var cs = await manager.GetClaimsAsync(user.Id);
currentExpected -= 2;
Assert.Equal(currentExpected, cs.Count());
Assert.Equal(currentExpected, db.Set<IdentityUserClaim>().Count());
}
}
public virtual async Task <IdentityResult> CreateUserClaimsAsync(TUserClaim claims)
{
var user = await UserManager.FindByIdAsync(claims.UserId.ToString());
return(await UserManager.AddClaimAsync(user, new Claim(claims.ClaimType, claims.ClaimValue)));
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// New user account registration, additional tasks
// Before attempting to add the user, let's validate the claims
// Reference to the manager
Manager m = new Manager();
// Status field to indicate whether the requested claims are allowed
// The first "not found" or malformed claim will change it to "false"
bool canRegister = true;
// Look at the role claims
foreach (var roleClaimValue in model.Roles)
{
if (m.AppClaimGetByMatch("role", roleClaimValue.Trim().ToLower()) == null)
{
canRegister = false;
}
}
// Look at the custom claims, add code here...
if (canRegister)
{
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// Add the new claims that were submitted by the user/requestor
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Email, model.Email));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, "User"));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.GivenName, model.GivenName));
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Surname, model.Surname));
foreach (var role in model.Roles)
{
await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, role));
}
// Add custom claims that were submitted by the user/requestor; add code here...
}
else
{
return(GetErrorResult(result));
}
return(Ok());
}
else
{
return(StatusCode(HttpStatusCode.BadRequest));
// We should give the user more useful info
}
}
public async Task <IHttpActionResult> GetRegisterExternal(string provider, string username, string error = null)
{
string redirectUri = string.Empty;
// if redirection is wrong don't even continue
string redirectUriValidationResult = ValidateClientAndRedirectUri(Request, ref redirectUri);
if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
{
return(BadRequest(redirectUriValidationResult));
}
if (error != null)
{
redirectUri = string.Format("{0}?&authenticated={1}&provider={2}&username={3}&token={4}&errorMessage={5}&operation={6}",
redirectUri,
"no",
provider,
username,
"",
Uri.EscapeDataString(error),
"register");
return(Redirect(redirectUri));
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(provider, this));
}
ExternalLoginInfo info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
redirectUri = string.Format("{0}?&authenticated={1}&provider={2}&username={3}&token={4}&errorMessage={5}&operation={6}",
redirectUri,
"no",
provider,
username,
"",
"The provider refused your Login, please check your Social security settings.",
"register");
return(Redirect(redirectUri));
}
// get the claims identity
ClaimsIdentity claimsIdentity = GetBasicUserIdentity(info);
// verify if user doesn't have already a login associated
CustomUser loginUser = await userManager.FindAsync(info.Login);
if (loginUser != null)
{
redirectUri = string.Format("{0}?&authenticated={1}&provider={2}&username={3}&token={4}&errorMessage={5}&operation={6}",
redirectUri,
"no",
provider,
username,
"",
string.Format("The User {0} has already an account {1} associated.", username, provider),
"register");
return(Redirect(redirectUri));
}
// search the User to be registered
CustomUser user = await userManager.FindByNameAsync(username);
// register login (from now on he can login with this provider)
await userManager.AddLoginAsync(user.Id, info.Login);
// for each claim generated, add the claim
foreach (var claim in claimsIdentity.Claims)
{
await userManager.AddClaimAsync(user.Id, claim);
}
redirectUri = string.Format("{0}?&authenticated={1}&provider={2}&username={3}&token={4}&errorMessage={5}&operation={6}",
redirectUri,
"yes",
provider,
username,
"",
"",
"register");
return(Redirect(redirectUri));
}
public async Task AddClaimAsync(string userId, Claim claim)
{
await _manager.AddClaimAsync(userId, claim).ConfigureAwait(false);
}
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (remoteError != null)
{
logger.LogError($"Error from external provider: {remoteError}");
return(RedirectToAction("Login", new { ReturnUrl = returnUrl }));
}
var info = await signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
logger.LogError("Error loading external login information.");
return(RedirectToAction("Login", new { ReturnUrl = returnUrl }));
}
ApplicationUser user = null;
if (info.LoginProvider == "IdStampIT")
{
string userId = commonService.Users_GetByLawUnitUIC(info.ProviderKey);
if (!string.IsNullOrEmpty(userId))
{
user = await userManager.FindByIdAsync(userId);
}
if (user == null)
{
SetErrorMessage("Невалиден потребител.");
return(RedirectToAction("Login", new { ReturnUrl = returnUrl }));
}
}
if (user == null)
{
user = await userManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
}
if (user != null)
{
var claims = await userManager.GetClaimsAsync(user);
var certNoClaim = claims.FirstOrDefault(c => c.Type == CustomClaimType.IdStampit.CertificateNumber);
var currentCertNoClaim = info.Principal.Claims.FirstOrDefault(c => c.Type == CustomClaimType.IdStampit.CertificateNumber);
if (currentCertNoClaim != null)
{
if (certNoClaim != null)
{
await userManager.ReplaceClaimAsync(user, certNoClaim, currentCertNoClaim);
}
else
{
await userManager.AddClaimAsync(user, currentCertNoClaim);
}
}
await signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("AccessDenied"));
}
public async Task <IActionResult> UpdateStaff(string id, [FromForm] SaveStaffDTO saveStaffDTO)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(BadRequest("Invalid User"));
}
var userClaims = await _userManager.GetClaimsAsync(user);
if (!string.IsNullOrEmpty(saveStaffDTO.PhoneNumber))
{
user.PhoneNumber = saveStaffDTO.PhoneNumber;
}
if (!string.IsNullOrEmpty(saveStaffDTO.Password))
{
var changePassword = await _userManager.ChangePasswordAsync(
user,
saveStaffDTO.CurrentPassword,
saveStaffDTO.Password);
if (!changePassword.Succeeded)
{
return(BadRequest(changePassword.Errors.SingleOrDefault().Description));
}
}
if (!string.IsNullOrEmpty(saveStaffDTO.Name))
{
// check for existing claim and remove it
var claim = userClaims.SingleOrDefault(c => c.Type == ClaimTypes.Name);
if (claim != null)
{
await _userManager.RemoveClaimAsync(user, claim);
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Name, saveStaffDTO.Name));
}
if (!string.IsNullOrEmpty(saveStaffDTO.Birthday))
{
// check for existing claim and remove it
var claim = userClaims.SingleOrDefault(c => c.Type == ClaimTypes.DateOfBirth);
if (claim != null)
{
await _userManager.RemoveClaimAsync(user, claim);
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.DateOfBirth, saveStaffDTO.Birthday));
}
if (!string.IsNullOrEmpty(saveStaffDTO.Gender))
{
// check for existing claim and remove it
var claim = userClaims.SingleOrDefault(c => c.Type == ClaimTypes.Gender);
if (claim != null)
{
await _userManager.RemoveClaimAsync(user, claim);
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Gender, saveStaffDTO.Gender));
}
if (!string.IsNullOrEmpty(saveStaffDTO.Identifier))
{
// check for existing claim and remove it
var claim = userClaims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
if (claim != null)
{
await _userManager.RemoveClaimAsync(user, claim);
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.NameIdentifier, saveStaffDTO.Identifier));
}
if (!string.IsNullOrEmpty(saveStaffDTO.Address))
{
// check for existing claim and remove it
var claim = userClaims.SingleOrDefault(c => c.Type == ClaimTypes.StreetAddress);
if (claim != null)
{
await _userManager.RemoveClaimAsync(user, claim);
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.StreetAddress, saveStaffDTO.Address));
}
await _userManager.UpdateAsync(user);
return(Ok());
}
public async Task InitializeData()
{
_context.Database.EnsureDeleted();
if (_context.Database.EnsureCreated())
{
Onderneming onderneming = new Onderneming()
{
Naam = "Hogeschool Gent"
};
_context.Ondernemingen.Add(onderneming);
//onvoldoende cheques beschikbaar, nog 2 openstaande prestatie waarvoor 7 cheques nodig
Gebruiker jan = new Gebruiker()
{
Naam = "Peeters",
Voornaam = "Jan",
Email = "*****@*****.**"
};
for (int i = 12; i >= 0; i--)
{
Prestatie pres = new Prestatie()
{
AantalUren = 4,
DatumPrestatie = DateTime.Today.AddMonths(-i),
PrestatieType = PrestatieType.Schoonmaken,
Onderneming = onderneming,
Betaald = true
};
jan.Prestaties.Add(pres);
}
jan.GetPrestatie(11).Betaald = false;
jan.GetPrestatie(12).Betaald = false;
int p = 0;
int pi = 0;
for (int i = 3; i > 0; i--)
{
Bestelling b = new Bestelling()
{
AantalAangekochteCheques = 15,
Elektronisch = true
};
b.StelDatumsIn(DateTime.Today.AddMonths(-4 * i), DateTime.Today.AddMonths(-4 * i));
jan.Bestellingen.Add(b);
for (int j = 1; j <= 15; j++)
{
DienstenCheque d = new DienstenCheque(true, DateTime.Today.AddMonths(-4 * i));
if (p < 11)
{
d.Prestatie = jan.GetPrestatie(p);
d.GebruiksDatum = d.Prestatie.DatumPrestatie;
}
jan.Portefeuille.Add(d);
if (pi < 3)
{
pi++;
}
else
{
pi = 0;
p++;
}
}
}
_context.Gebruikers.Add(jan);
ApplicationUser user1 = new ApplicationUser {
UserName = jan.Email, Email = jan.Email
};
await _userManager.CreateAsync(user1, "P@ssword1");
await _userManager.AddClaimAsync(user1, new Claim(ClaimTypes.Role, "customer"));
//alle cheques zijn toegewezen aan prestaties, geen openstaande prestatie meer
Gebruiker an = new Gebruiker()
{
Naam = "Pieters", Voornaam = "An", Email = "*****@*****.**"
};
Bestelling anBestelling = new Bestelling()
{
AantalAangekochteCheques = 20, Elektronisch = true
};
anBestelling.StelDatumsIn(DateTime.Today.AddMonths(-1), DateTime.Today.AddMonths(-1));
an.Bestellingen.Add(anBestelling);
for (int i = 4; i > 0; i--)
{
an.Prestaties.Add(new Prestatie()
{
AantalUren = 5, DatumPrestatie = DateTime.Today.AddMonths(-i), PrestatieType = PrestatieType.Schoonmaken, Onderneming = onderneming, Betaald = true
});
}
for (int j = 0; j <= 19; j++)
{
DienstenCheque d = new DienstenCheque(true, DateTime.Today.AddMonths(-1));
d.Prestatie = an.GetPrestatie(j / 5);
d.GebruiksDatum = d.Prestatie.DatumPrestatie;
an.Portefeuille.Add(d);
}
_context.Gebruikers.Add(an);
ApplicationUser user2 = new ApplicationUser {
UserName = an.Email, Email = an.Email
};
await _userManager.CreateAsync(user2, "P@ssword1");
await _userManager.AddClaimAsync(user2, new Claim(ClaimTypes.Role, "customer"));
//nog 2 cheques niet gebruikt, geen openstaande prestaties
Gebruiker tine = new Gebruiker()
{
Naam = "Pieters", Voornaam = "Tine", Email = "*****@*****.**"
};
Bestelling tineBestelling = new Bestelling()
{
AantalAangekochteCheques = 6, Elektronisch = true
};
tineBestelling.StelDatumsIn(DateTime.Today.AddMonths(-1), DateTime.Today.AddMonths(-1));
tine.Bestellingen.Add(tineBestelling);
tine.Prestaties.Add(new Prestatie()
{
AantalUren = 4, DatumPrestatie = DateTime.Today.AddDays(-10), PrestatieType = PrestatieType.Schoonmaken, Onderneming = onderneming, Betaald = true
});
for (int j = 1; j <= 6; j++)
{
DienstenCheque d = new DienstenCheque(true, DateTime.Today.AddMonths(-1));
if (j < 5)
{
d.Prestatie = tine.GetPrestatie(0);
d.GebruiksDatum = d.Prestatie.DatumPrestatie;
}
tine.Portefeuille.Add(d);
}
_context.Gebruikers.Add(tine);
ApplicationUser user3 = new ApplicationUser {
UserName = tine.Email, Email = tine.Email
};
await _userManager.CreateAsync(user3, "P@ssword1");
await _userManager.AddClaimAsync(user3, new Claim(ClaimTypes.Role, "customer"));
_context.SaveChanges();
}
}
public static async void ConfigureUsers(IEnumerable<InMemoryUser> users, EntityFrameworkServiceOptions options, UserManager userManager) {
using(var db = new Contexto(options.ConnectionString)) {
if(!db.Users.Any()) {
foreach(var u in users) {
var entity = new Usuario { Email = u.Claims.First(x=>x.Type==Constants.ClaimTypes.Email).Value , UserName = u.Username };
var response = await userManager.CreateAsync(entity, u.Password);
if(!response.Succeeded) {
throw new Exception("Não foi possível criar o usuario" + u.Username + response.Errors.ToString());
}
else {
var user = await userManager.FindAsync(u.Username,u.Password);
foreach(var c in u.Claims) {
await userManager.AddClaimAsync(user.Id,c);
}
await userManager.UpdateAsync(user);
}
}
db.SaveChanges();
}
}
}
