public static void InternalSeed(CustomDbContext db)
{
var userManager = HttpContext.Current.GetOwinContext().GetUserManager<CustomUserManager>();
var roleManager = HttpContext.Current.GetOwinContext().Get<CustomRoleManager>();
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = roleManager.FindByName(roleName);
if (role == null)
{
role = new CustomRole(roleName);
var roleresult = roleManager.Create(role);
}
var user = userManager.FindByName(name);
if (user == null)
{
user = new CustomUser { UserName = name, Email = name };
var result = userManager.Create(user, password);
result = userManager.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = userManager.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var result = userManager.AddToRole(user.Id, role.Name);
}
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
CustomRole customRole = await db.CustomRoles.FindAsync(id);
db.CustomRoles.Remove(customRole);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void SeedDatabase()
{
const string name = "*****@*****.**";
const string password = "******";
//const string roleName = "Admin";
const string privateName = "private";
const string protectName = "protect";
const string publicName = "public";
var privateRole = _roleManager.FindRoleByName(privateName);
var protectRole = _roleManager.FindRoleByName(protectName);
var publicRole = _roleManager.FindRoleByName(publicName);
if (privateRole == null)
{
privateRole = new CustomRole(privateName);
var privateResult = _roleManager.CreateRole(privateRole);
}
if (protectRole == null)
{
protectRole = new CustomRole(protectName);
var protectResult = _roleManager.CreateRole(protectRole);
}
if (publicRole == null)
{
publicRole = new CustomRole(publicName);
var publicResult = _roleManager.CreateRole(publicRole);
}
//Create Role Admin if it does not exist
var user = this.FindByName(name);
if (user == null)
{
user = new ApplicationUser
{
UserName = name,
Email = name,
EmailConfirmed = true,
RegisterDate = DateTime.Now.Date,
DateDisableUser = DateTime.Parse("2001/1/1")
};
var result = this.Create(user, password);
result = this.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = this.GetRoles(user.Id);
if (!rolesForUser.Contains(privateRole.Name))
{
var result = this.AddToRole(user.Id, privateRole.Name);
}
}
private void AddUsersAndRoles()
{
MAPContext context = new MAPContext();
var roleManager = new RoleManager <CustomRole, int>(new RoleStore <CustomRole, int, CustomUserRole>(context));
var UserManager = new UserManager <Users, int>(new UserStore <Users, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(context));
// In Startup iam creating first Admin Role and creating a default Admin User
var role = new CustomRole();
if (!roleManager.RoleExists("Client"))
{
role.Name = "Client";
roleManager.Create(role);
}
if (!roleManager.RoleExists("Ressource"))
{
role.Name = "Ressource";
roleManager.Create(role);
}
if (!roleManager.RoleExists("Applicant"))
{
role.Name = "Applicant";
roleManager.Create(role);
}
if (!roleManager.RoleExists("Responsable"))
{
role.Name = "Responsable";
roleManager.Create(role);
}
if (!roleManager.RoleExists("SuperAdmin"))
{
role.Name = "SuperAdmin";
roleManager.Create(role);
}
if (UserManager.FindByName("SuperAdmin") == null)
{
var user = new Users
{
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var Password = "******";
var chkUser = UserManager.Create(user, Password);
if (chkUser.Succeeded)
{
var result1 = UserManager.AddToRole(user.Id, "SuperAdmin")
;
}
}
}
// In this method we will create default User roles and Admin user for login
private void createRolesandUsers()
{
ApplicationDbContext context = new ApplicationDbContext();
var roleManager = new RoleManager <CustomRole, int>(new CustomRoleStore(context));
var UserManager = new UserManager <ApplicationUser, int>(new CustomUserStore(context));
// In Startup iam creating first Admin Role and creating a default Admin User
if (!roleManager.RoleExists("Admin"))
{
// first we create Admin rool
var role = new CustomRole();
role.Name = "Admin";
roleManager.Create(role);
//Here we create a Admin super user who will maintain the website
var user = new ApplicationUser();
user.UserName = ConfigurationManager.AppSettings["AdminUserName"];
user.Email = ConfigurationManager.AppSettings["AdminEmailId"];
var x = ConfigurationManager.GetSection("appSettings");
string userPWD = ConfigurationManager.AppSettings["AdminPassword"];
var chkUser = UserManager.Create(user, userPWD);
//Add default User to Role Admin
if (chkUser.Succeeded)
{
var result1 = UserManager.AddToRole(user.Id, "Admin");
}
}
// creating Creating Teacher role
if (!roleManager.RoleExists("Teacher"))
{
var role = new CustomRole();
role.Name = "Teacher";
roleManager.Create(role);
}
// creating Creating Student role
if (!roleManager.RoleExists("Student"))
{
var role = new CustomRole();
role.Name = "Student";
roleManager.Create(role);
}
// creating Creating Employee role
if (!roleManager.RoleExists("Staff"))
{
var role = new CustomRole();
role.Name = "Staff";
roleManager.Create(role);
}
}
public ActionResult Edit([Bind(Include = "Id,Name")] CustomRole customRole)
{
if (ModelState.IsValid)
{
db.Entry(customRole).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(customRole));
}
public async Task <ActionResult> Edit(RoleViewModel model)
{
var role = new CustomRole()
{
Id = model.Id, Name = model.Name
};
await RoleManager.UpdateAsync(role);
return(RedirectToAction("Index"));
}
/// <summary>
/// Find a role by name
/// </summary>
/// <param name="roleName"/>
/// <returns/>
Task <CustomRole> IRoleStore <CustomRole, string> .FindByNameAsync(string roleName)
{
var role = databaseContext.Set <RoleAggregate>()
.Single(x => x.Name == roleName);
var customRole = CustomRole.Create(
id: role.Id.ToString(),
name: role.Name);
return(Task.Run(() => { return customRole; }));
}
public JsonResult Create(CustomRole Role)
{
context.Roles.Add(Role);
context.SaveChanges();
var addedRole = context.Roles
.Where(r => r.Name == Role.Name)
.Select(r => new { r.Id, r.Name, r.Description });
return(Json(addedRole.FirstOrDefault()));
}
public static CustomRoleIdentityQueryDTO From(CustomRole data)
{
return(new CustomRoleIdentityQueryDTO
{
Id = data.Id,
Name = data.Name,
Description = data.Description,
AccessPointKeys = data.AccessPointKeys
});
}
public Task UpdateAsync(CustomRole role)
{
var userAggregate = databaseContext
.Set <RoleAggregate>()
.SingleOrDefault(x => x.Id.ToString() == role.Id);
// update logic
return(databaseContext.SaveChangesAsync());
}
public void SeedDatabase()
{
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = _roleManager.FindRoleByName(roleName);
if (role == null)
{
role = new CustomRole(roleName);
var roleResult = _roleManager.CreateRole(role);
if (!roleResult.Succeeded)
{
throw new InvalidOperationException(string.Join(", ", roleResult.Errors));
}
}
try
{
var user = this.FindByName(name);
if (user == null)
{
user = new User {
UserName = name, Email = name
};
var createResult = this.Create(user, password);
if (!createResult.Succeeded)
{
throw new InvalidOperationException(string.Join(", ", createResult.Errors));
}
var setLockoutResult = this.SetLockoutEnabled(user.Id, false);
if (!setLockoutResult.Succeeded)
{
throw new InvalidOperationException(string.Join(", ", setLockoutResult.Errors));
}
}
// Add user admin to Role Admin if not already added
var rolesForUser = this.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var addToRoleResult = this.AddToRole(user.Id, role.Name);
if (!addToRoleResult.Succeeded)
{
throw new InvalidOperationException(string.Join(", ", addToRoleResult.Errors));
}
}
}
catch (Exception)
{
throw;
}
}
public async Task <JsonResult> CreateRole([FromBody] CustomRole odata)
{
var response = "false";
try
{
if (odata.Id == null || odata.Id == "")
{
odata.Id = db.GenerateUniqueId();
odata.Name = odata.RoleName;
var result = await roleManager.CreateAsync(odata);
if (result.Succeeded)
{
response = "true";
}
else
{
foreach (var error in result.Errors)
{
response = response + "," + error.Code;
}
}
}
else
{
var existing = await db.CustomRoleList.AsNoTracking().FirstOrDefaultAsync(x => x.Id == odata.Id);
if (existing != null)
{
existing.RoleName = odata.RoleName;
var result = await roleManager.UpdateAsync(existing);
if (result.Succeeded)
{
response = "true";
}
else
{
foreach (var error in result.Errors)
{
response = response + "," + error.Code;
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(Json(response));
}
public Task DeleteAsync(CustomRole role)
{
var roleAggregate = databaseContext
.Set <RoleAggregate>()
.Where(x => x.Id.ToString() == role.Id)
.Single();
databaseContext.Set <RoleAggregate>().Remove(roleAggregate);
return(databaseContext.SaveChangesAsync());
}
public async Task UpdateAsync(CustomRole entity)
{
var updateEntity = await _context.Roles.FirstOrDefaultAsync(r => r.Id == entity.Id);
if (updateEntity is null)
{
throw new ArgumentException("Can't find a role by Id", "entity");
}
updateEntity.UserRole = entity.UserRole;
}
public ActionResult Create([Bind(Include = "Id,Name")] CustomRole customRole)
{
if (ModelState.IsValid)
{
db.Roles.Add(customRole);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(customRole));
}
/// <summary>
/// Method SetAuthorize, mengatur autorisasi pengguna yang memiliki hak akses terhadap SFS
/// </summary>
private void SetAuthorize()
{
CustomAuthentication.CustomRole customeRole = new CustomRole();
bool isPPC = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.PPC);
bool isAdmin = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.Administrator);
bool isPE = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.PE);
bool isForeman = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.Foreman);
bool isInspector = customeRole.IsUserInRole(User.Identity.Name, RoleNames.Inspector);
Session["IsViewOnly"] = isPPC || isAdmin || isPE || isForeman || isInspector;
}
public static string ToFriendlyString(CustomRole role)
{
switch (role)
{
case CustomRole.User:
return("@everyone");
case CustomRole.Moderator:
return("Moderator");
}
return("");
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
Surname = Input.Surname,
PhoneNumber = Input.PhoneNumber
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
if (!_roleManager.RoleExistsAsync("Editor").Result)
{
CustomRole role = new CustomRole();
role.Name = "Editor";
await _roleManager.CreateAsync(role);
await _userManager.AddToRoleAsync(user, role.Name);
}
else
{
_userManager.AddToRoleAsync(user, "Editor").Wait();
}
//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());
}
// Post: Admin/Tag/Delete/id
public virtual ActionResult Delete(int id)
{
CustomRole tag = _roleService.FindByIdAsync(id).Result;
if (tag == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
_roleService.DeleteAsync(tag);
_uow.SaveAllChanges();
return(Json(new { success = true }));
}
// In this method we will create default User roles and Admin user for login
private void createRolesandUsers()
{
ApplicationDbContext context = new ApplicationDbContext();
var roleManager = new RoleManager <CustomRole, int>(new CustomRoleStore(context));
var UserManager = new UserManager <ApplicationUser, int>(new CustomUserStore(context));
//// In Startup iam creating first Admin Role and creating a default Admin User
//if (!roleManager.RoleExists("Admin"))
//{
// // first we create Admin rool
// var role = new CustomRole();
// role.Name = "Admin";
// roleManager.Create(role);
// //Here we create a Admin super user who will maintain the website
// var user = new ApplicationUser();
// user.UserName = "******";
// user.Email = "*****@*****.**";
// string userPWD = "A@Z200711";
// var chkUser = UserManager.Create(user, userPWD);
// //Add default User to Role Admin
// if (chkUser.Succeeded)
// {
// var result1 = UserManager.AddToRole(user.Id, "Admin");
// }
//}
// creating Creating Manager role
if (!roleManager.RoleExists("Manager"))
{
var role = new CustomRole();
role.Name = "Manager";
roleManager.Create(role);
}
// creating Creating User role
if (!roleManager.RoleExists("User"))
{
var role = new CustomRole();
role.Name = "User";
roleManager.Create(role);
}
}
public override void OnEnabled()
{
Singleton = this;
CustomRole.RegisterRoles();
EventHandlers = new EventHandlers(this);
Npc = new NestingObjects.Npc(this);
Playable = new NestingObjects.Playable(this);
Server.WaitingForPlayers += EventHandlers.OnWaitingForPlayers;
Exiled.Events.Handlers.Player.SpawningRagdoll += EventHandlers.OnSpawningRagdoll;
base.OnEnabled();
}
/// <inheritdoc />
public override void OnDisabled()
{
_harmony.UnpatchAll(_harmonyId);
CustomItem.UnregisterItems();
CustomRole.RegisterRoles();
Exiled.Events.Handlers.Server.EndingRound -= EventHandlers.OnEndingRound;
Exiled.Events.Handlers.Player.SpawningRagdoll -= EventHandlers.OnSpawningRagdoll;
EventHandlers = null;
Instance = null;
base.OnDisabled();
}
public async Task <IActionResult> AddRole([Bind("Description,Id, Name")] CustomRole applicationRole)
{
applicationRole.DateCreated = DateTime.Now;
if (ModelState.IsValid)
{
await _roleManager.CreateAsync(applicationRole);
_context.Add(applicationRole);
// await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(applicationRole));
}
public int AddRole(string name)
{
CustomRole role = new CustomRole
{
Name = name
};
var result = _roleManager.CreateAsync(role).Result;
if (result.Succeeded)
{
return(role.Id);
}
return(0);
}
// GET: CustomRoles/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CustomRole customRole = db.Roles.Find(id);
if (customRole == null)
{
return(HttpNotFound());
}
return(View(customRole));
}
// GET: CustomRoles/Details/5
public async Task <ActionResult> Details(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CustomRole customRole = await db.CustomRoles.FindAsync(id);
if (customRole == null)
{
return(HttpNotFound());
}
return(View(customRole));
}
public async Task<ActionResult> Create(RoleViewModel roleViewModel)
{
if (ModelState.IsValid)
{
var role = new CustomRole(roleViewModel.Name);
var roleresult = await RoleManager.CreateAsync(role);
if (!roleresult.Succeeded)
{
ModelState.AddModelError("", roleresult.Errors.First());
return View();
}
return RedirectToAction("Index");
}
return View();
}
public async Task <ActionResult> Create(RoleViewModel roleViewModel)
{
if (ModelState.IsValid)
{
var role = new CustomRole(roleViewModel.Name);
var roleresult = await _roleManager.CreateAsync(role).ConfigureAwait(false);
if (!roleresult.Succeeded)
{
ModelState.AddModelError("", roleresult.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new user
{
Email = model.Email,
UserName = model.Email,
fName = model.fName,
AccountState = true,
DTYPE = "user", //a ne plus toucher
age = model.age,
pwd = model.Password, //il va sauvgarder dans password la valeur entrer
MyOrganization_id = null
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
CustomRole role = new CustomRole(user.DTYPE);
var manage = HttpContext.GetOwinContext().GetUserManager <gloventdbContext>();
if (manage.Roles.Count(r => r.Name.Equals(user.DTYPE)) == 0)
{
manage.Roles.Add(role);
manage.SaveChanges();
}
UserManager.AddToRole(user.Id, user.DTYPE);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public override void OnDisabled()
{
CustomRole.UnregisterRoles();
foreach (CoroutineHandle handle in EventHandlers.Coroutines)
{
Timing.KillCoroutines(handle);
}
EventHandlers.Coroutines.Clear();
Server.WaitingForPlayers -= EventHandlers.OnWaitingForPlayers;
Exiled.Events.Handlers.Player.SpawningRagdoll -= EventHandlers.OnSpawningRagdoll;
EventHandlers = null;
Npc = null;
Playable = null;
base.OnDisabled();
}
public void SeedDatabase()
{
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = _roleManager.FindRoleByName(roleName);
if (role == null)
{
role = new CustomRole(roleName);
var roleresult = _roleManager.CreateRole(role);
}
var user = this.FindByName(name);
if (user == null)
{
user = new ApplicationUser {
UserName = name, Email = name
};
var result = this.Create(user, password);
result = this.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = this.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var result = this.AddToRole(user.Id, role.Name);
}
//_postService.Create(new ViewModel.PostViewModel
//{
// PostedByUserId = user.Id,
// Body = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx",
// AddedBy = "Kamal",
// Title = "new title",
// ViewNumber = 0
//});
}
public async Task<IHttpActionResult> AddRole(CreateRoleModel role)
{
CustomRole r = new CustomRole(role.NewRole);
IdentityResult result = await RoleManager.CreateAsync(r);
if (!result.Succeeded)
{
return GetErrorResult(result);
}
return Ok();
}
public async Task<ActionResult> RoleCreate(string roleName)
{
//RoleManager.CreateAsync(new CustomRole(roleName));
// Use ApplicationRole, not IdentityRole:
var role = new CustomRole(roleName);
var roleresult = await RoleManager.CreateAsync(role);
if (roleresult.Succeeded)
{
ViewBag.ResultMessage = "Role created successfully !";
return RedirectToAction("RoleIndex", "Account");
}
return RedirectToAction("Index", "Home");
}
