/// <summary>
/// Creates an instance of <see cref="SecurityUserControl"/> class.
/// </summary>
public SecurityUserControl()
{
InitializeComponent();
m_userAccounts = new UserAccounts(1, false);
m_securityGroups = new SecurityGroups(1, false);
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
this.Unloaded += new RoutedEventHandler(SecurityUserControl_Unloaded);
m_userAccounts.BeforeSave += new System.ComponentModel.CancelEventHandler(m_userAccounts_BeforeSave);
m_userAccounts.Saved += new System.EventHandler(m_userAccounts_Changed);
m_userAccounts.Deleted += new System.EventHandler(m_userAccounts_Changed);
m_securityGroups.Saved += new System.EventHandler(m_securityGroups_Changed);
m_securityGroups.Deleted += new System.EventHandler(m_securityGroups_Changed);
m_invalidPasswordMessage = new StringBuilder();
m_invalidPasswordMessage.Append("Password does not meet the following criteria:");
m_invalidPasswordMessage.AppendLine();
m_invalidPasswordMessage.Append("- Password must be at least 8 characters");
m_invalidPasswordMessage.AppendLine();
m_invalidPasswordMessage.Append("- Password must contain at least 1 digit");
m_invalidPasswordMessage.AppendLine();
m_invalidPasswordMessage.Append("- Password must contain at least 1 upper case letter");
m_invalidPasswordMessage.AppendLine();
m_invalidPasswordMessage.Append("- Password must contain at least 1 lower case letter");
}
public ActionResult Create(RoleViewModel RoleView)
{
ViewBag.Current = "Roles";
if (ModelState.IsValid)
{
//Duplicated Role Name in DB:
if (manger.Roles.Any(a => a.Name.Equals(RoleView.Name, StringComparison.OrdinalIgnoreCase)))
{
return(RedirectToAction("Index", new { Id = "CreateError" }));
}
ApplicationRoles role = new ApplicationRoles()
{
Name = RoleView.Name,
CreatedAt = DateTime.Now.ToString("dd/MM/yyyy-HH:mm:ss"),
CreatedById = this.User.Identity.GetUserId()
};
//OK:
manger.Create(role);
string NotificationTime = DateTime.Now.ToString("dd/MM/yyyy-HH:mm:ss");
string UserId = User.Identity.GetUserId();
Notification notification = null;
List <ApplicationUser> Users = db.Users.Where(a => a.RoleName.Equals("Master") && !a.Id.Equals(UserId)).ToList();
foreach (ApplicationUser user in Users)
{
notification = new Notification()
{
CreatedAt = NotificationTime,
Active = false,
UserId = user.Id,
Message = "تم إضافة دور جديد : " + role.Name
,
NotificationOwnerId = UserId
};
db.Notifications.Add(notification);
}
db.SaveChanges();
return(RedirectToAction("Index", new { Id = "CreateSuccess" }));
}
return(RedirectToAction("Index"));
}
private void BindDdllistRole(int ID, int AppID)
{
if (ID != 0)
{
AppID = userAdminObj.GetAppID(ID);
}
var result = userAdminObj.GetRole(AppID, GlobalConstant.NewAccess);
var LstRoleID = userAdminObj.GetApprovalMatrixsRole(AppID);
List <ApplicationRoles> appRolesList = new List <ApplicationRoles>();
int count = 0;
foreach (var item in result)
{
foreach (var item2 in LstRoleID)
{
if (item2.RoleID == item.RoleID)
{
count = 1;
}
}
if (count != 1)
{
ApplicationRoles appRole = new ApplicationRoles();
appRole.RoleID = item.RoleID;
appRole.RoleName = item.RoleName;
appRolesList.Add(appRole);
}
count = 0;
}
if (ID != 0)
{
ddlRole.DataSource = result.ToList();
}
else
{
ddlRole.DataSource = appRolesList.ToList();
}
ddlRole.DataTextField = "RoleName";
ddlRole.DataValueField = "RoleID";
ddlRole.DataBind();
if (LstRoleID.Count() == result.Count() && ID == 0)
{
showMessages((int)GlobalConstant.DrawControls.Warning, "Roles Already exist in Approval Matrix, Please Select \"Edit\" to modify the Approver.", true);
btnUpdate.Visible = false;
}
}
public async Task <ActionResult> Edit(RegiterViewModelWithRole registertViewModel)
{
try
{
if (registertViewModel != null)
{
Task <ApplicationUsers> applicationUsers = accountManager.GetUserByIdAsync(registertViewModel.Id.ToString());
Task <ApplicationRoles> roleName = accountManager.GetRoleByIdAsync(registertViewModel.RoleId.ToString());
ApplicationUsers _applicationUsers = await applicationUsers;
ApplicationRoles _roleName = await roleName;
if (_applicationUsers != null && _roleName != null)
{
_applicationUsers.Email = registertViewModel.Email;
_applicationUsers.MobileNumber = registertViewModel.MobileNo;
_applicationUsers.LockoutEnabled = registertViewModel.IsLocked;
_applicationUsers.GSTNumber = registertViewModel.GSTNumber;
_applicationUsers.CountryFK = registertViewModel.CountryFK;
_applicationUsers.StateFK = registertViewModel.StateFK;
_applicationUsers.CityFK = registertViewModel.CityFK;
_applicationUsers.NewsPaperCompany = registertViewModel.NewsPaperCompany;
_applicationUsers.PressReporterName = registertViewModel.PressReporterName;
_applicationUsers.PressIDCard = registertViewModel.PressIDCard;
(bool status, string[] response) = await accountManager.UpdateUserAsync(_applicationUsers, new string[] { _roleName.Name });
if (status)
{
return(RedirectToAction("Index", "Users", new { @id = registertViewModel.RoleId }));
}
else
{
ModelState.AddModelError(Helpers.EnumAlert.Error.ToString(), string.Join(",", response));
}
}
else
{
ModelState.AddModelError(Helpers.EnumAlert.Error.ToString(), "User or Role not found");
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(Helpers.EnumAlert.Error.ToString(), string.Join(",", ex.InnerException));
return(View(registertViewModel));
}
registertViewModel.GetRoles = new RoleHelper(repository).GetRoles(Guid.Empty);
return(View(registertViewModel));
}
protected void AddUserRole(UserEntityModel user, ApplicationRoles role)
{
// Add User Roles.
var showAllRole = new UserRoleEntityModel
{
RoleId = role.GetEnumGuid(),
User = user
};
Context.UserRoles.Add(showAllRole);
Context.SaveChanges();
// Reload Factory.
Factory = new ServiceFactory(Context, Identity);
Trace.WriteLine($"Added '{role}' Role to User -> {user.UserName}");
}
public async Task <IActionResult> DeleteApplicationRole(string id, IFormCollection form)
{
if (!String.IsNullOrEmpty(id))
{
ApplicationRoles applicationRole = await _roleManager.FindByIdAsync(id);
if (applicationRole != null)
{
IdentityResult result = _roleManager.DeleteAsync(applicationRole).Result;
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
}
}
return(View());
}
public async Task <IActionResult> AddEditApplicationRole(string id)
{
RolesViewModel model = new RolesViewModel();
if (!String.IsNullOrEmpty(id))
{
ApplicationRoles applicationRole = await _roleManager.FindByIdAsync(id);
if (applicationRole != null)
{
model.Id = applicationRole.Id;
model.Name = applicationRole.Name;
model.Description = applicationRole.Description;
}
}
return(PartialView("_AddEditApplicationRole", model));
}
public async Task <IActionResult> singup(AccountViewModel viewModel)
{
if (ModelState.IsValid)
{
ApplicationUsers applicationUser = AutoMapper.Mapper.Map <ApplicationUsers>(viewModel.RegistertViewModel);
ApplicationRoles roleName = await accountManager.GetRoleByNameAsync(EnumApplicationUser.USER.ToString());
(bool success, string[] result) = await accountManager.CreateUserAsync(applicationUser, new string[] { roleName.Name }, viewModel.RegistertViewModel.Password);
if (success)
{
}
else
{
ModelState.AddModelError(EnumAlert.Error.ToString(), string.Join(",", result));
}
}
return(RedirectToAction("index"));
}
public async Task <IActionResult> Register(UsersViewModel usersViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Something failed");
return(View());
}
ApplicationUsers applicationUsers = new ApplicationUsers
{
Name = usersViewModel.Name,
UserName = usersViewModel.Username,
Email = usersViewModel.Email,
Address = usersViewModel.Address,
Country = usersViewModel.Country,
DateOfBirth = usersViewModel.DateOfBirth,
City = usersViewModel.City,
Region = usersViewModel.Region,
Gender = usersViewModel.Gender,
Contact = usersViewModel.Contact,
EmailConfirmed = false
};
IdentityResult result = await _userManager.CreateAsync(applicationUsers, usersViewModel.Password);
if (result.Succeeded)
{
ApplicationRoles applicationRoles = await _roleManager.FindByNameAsync("User");
if (applicationRoles != null)
{
IdentityResult roleResult =
await _userManager.AddToRoleAsync(applicationUsers, applicationRoles.Name);
if (roleResult.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
}
return(View(usersViewModel));
}
public async Task <IActionResult> Update(string id)
{
ApplicationRoles role = await roleManager.FindByIdAsync(id);
List <ApplicationUser> members = new List <ApplicationUser>();
List <ApplicationUser> nonMembers = new List <ApplicationUser>();
foreach (ApplicationUser user in userManager.Users)
{
var list = await userManager.IsInRoleAsync(user, role.Name) ? members : nonMembers;
list.Add(user);
}
return(View(new RoleEdit
{
Role = role,
Members = members,
NonMembers = nonMembers
}));
}
public async Task <IActionResult> Edit(string id, ApplicationRoles role)
{
if (id != role.Id || !ModelState.IsValid)
{
return(View("EditRole", role));
}
var roleFromDb = await _roleManager.FindByIdAsync(id);
if (roleFromDb == null)
{
return(NotFound("No role item"));
}
roleFromDb.Name = role.Name;
roleFromDb.Description = role.Description;
roleFromDb.NormalizedName = role.Name.ToLower();
await _roleManager.UpdateAsync(roleFromDb);
return(RedirectToAction("Index"));
}
public static bool CanReadFile(string filePath, ApplicationRoles userRole)
{
switch (userRole)
{
case ApplicationRoles.admin:
{
return(true);
}
case ApplicationRoles.employee:
{
return(filePath.EndsWith(".xml"));
}
default:
{
return(false);
}
}
}
public async Task <IActionResult> Create(ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
ApplicationRoles role = new ApplicationRoles();
role.Name = model.Name;
role.Description = model.Description;
role.RoleLevel = model.RoleLevel;
IdentityResult result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
ViewBag.ViewTitle = "تعریف اجزای سیستم";
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public IEnumerable <ApplicationRoles> GetApprovalMatrixsRole(int AppID)
{
sqlconn = new SqlConnection(sqlconnectionstring);
sqlconn.Open();
string SP = GlobalConstant.USP_GetApprovalMatrixs;
sqlcmd = new SqlCommand(SP, sqlconn);
sqlcmd.CommandType = CommandType.StoredProcedure;
sqlcmd.Parameters.AddWithValue("@AppID", AppID);
SqlDataReader returnLst = sqlcmd.ExecuteReader();
List <ApplicationRoles> Lstmenu = new List <ApplicationRoles>();
while (returnLst.Read())
{
ApplicationRoles m = new ApplicationRoles();
m.RoleID = (int)returnLst["RoleID"];
Lstmenu.Add(m);
}
sqlconn.Close();
return(Lstmenu);
}
public async Task <IActionResult> SignUp(UsersViewModel model)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Something wrong");
return(View(model));
}
ApplicationUsers user = new ApplicationUsers
{
Name = model.Name,
UserName = model.UserName,
Email = model.Email,
Address = model.Address,
Refference = model.Refference,
CityId = model.CityId,
DateOfBirth = model.DateOfBirth,
Gender = model.Gender,
JoinIp = "1234",
Contact = model.Contact,
EmailConfirmed = false,
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
ApplicationRoles applicationRoles = await _roleManager.FindByNameAsync("user");
if (applicationRoles != null)
{
IdentityResult roleResult = await _userManager.AddToRoleAsync(user, applicationRoles.Name);
if (roleResult.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
}
return(View(model));
}
/// <summary>
/// Fetches the LADP details for current login user
/// </summary>
/// <returns></returns>
//public bool GetUserDetailsFromLDAP()
//{
//LDAP.LDAP ldapConnection = new LDAP.LDAP();
//string StampUserId = (Thread.CurrentPrincipal.Identity).Name;
//int start = StampUserId.IndexOf("\\");
//StampUserId = StampUserId.Substring(start + 1).ToString();
//ldapConnection.SetLdapConnection(StampUserId, LDAPConfiguration.GetResourceName("LDAP_CONNECTION"));
//this.RequestorName = ldapConnection.LastName + ", " + ldapConnection.GivenName;
//this.RequestorEmail = ldapConnection.Email;
//return true;
//}
/// <summary>
/// Get Role from the Application
/// </summary>
/// <param name="AppID"></param>
/// <returns></returns>
public IEnumerable <ApplicationRoles> GetRole(int AppID, string NewAccess)
{
sqlconn = new SqlConnection(sqlconnectionstring);
sqlconn.Open();
string SP = GlobalConstant.USP_GetApplicationAccessDetails;
sqlcmd = new SqlCommand(SP, sqlconn);
sqlcmd.CommandType = CommandType.StoredProcedure;
sqlcmd.Parameters.AddWithValue("@AppID", AppID);
sqlcmd.Parameters.AddWithValue("@RequestType", NewAccess);
SqlDataReader returnLst = sqlcmd.ExecuteReader();
ConStringAndSP conStrSP = new ConStringAndSP();
while (returnLst.Read())
{
conStrSP.ConnString = returnLst["ConnString"].ToString();
conStrSP.StoredProcedure = returnLst["StoredProcedure"].ToString();
}
sqlconn.Close();
sqlconn = new SqlConnection(conStrSP.ConnString);
sqlconn.Open();
string appSP = conStrSP.StoredProcedure;
sqlcmd = new SqlCommand(appSP, sqlconn);
sqlcmd.CommandType = CommandType.StoredProcedure;
SqlDataReader appRoleLst = sqlcmd.ExecuteReader();
List <ApplicationRoles> Lstmenu = new List <ApplicationRoles>();
while (appRoleLst.Read())
{
ApplicationRoles m = new ApplicationRoles();
m.RoleID = (int)appRoleLst["RoleID"];
m.AppID = AppID;
m.RoleName = appRoleLst["RoleName"].ToString();
Lstmenu.Add(m);
}
sqlconn.Close();
return(Lstmenu);
}
public static void SeedRoles(RoleManager <ApplicationRoles> roleManager)
{
if (!roleManager.RoleExistsAsync
("User").Result)
{
ApplicationRoles role = new ApplicationRoles
{
Name = "User",
Description = "Perform normal operations."
};
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync
("Admin").Result)
{
ApplicationRoles role = new ApplicationRoles
{
Name = "Admin",
Description = "Perform all the operations."
};
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync
("Editor").Result)
{
ApplicationRoles role = new ApplicationRoles
{
Name = "Editor",
Description = "Can Edit all the operations."
};
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
}
public ActionResult Confirm(string Id)
{
ViewBag.Current = "Roles";
//Delete Permission roles:
List <PermissionRole> PRoles = db.PermissionRoles.Where(a => a.RoleId.Equals(Id)).ToList();
foreach (PermissionRole PR in PRoles)
{
db.PermissionRoles.Remove(PR);
}
ApplicationRoles AppRole = manger.Roles.FirstOrDefault(a => a.Id.Equals(Id));
db.Roles.Remove(AppRole);
db.SaveChanges();
string NotificationTime = DateTime.Now.ToString("dd/MM/yyyy-HH:mm:ss");
string UserId = User.Identity.GetUserId();
Notification notification = null;
List <ApplicationUser> Users = db.Users.Where(a => a.RoleName.Equals("Master") && !a.Id.Equals(UserId)).ToList();
foreach (ApplicationUser user in Users)
{
notification = new Notification()
{
CreatedAt = NotificationTime,
Active = false,
UserId = user.Id,
Message = "تم حذف الدور : " + AppRole.Name
,
NotificationOwnerId = UserId
};
db.Notifications.Add(notification);
}
db.SaveChanges();
return(RedirectToAction("Index", new { Id = "DeleteSuccess" }));
}
private void SecurityUserControl_Unloaded(object sender, RoutedEventArgs e)
{
try
{
if (m_userAccounts != null)
{
m_userAccounts.BeforeSave -= m_userAccounts_BeforeSave;
m_userAccounts.Saved -= m_userAccounts_Changed;
m_userAccounts.Deleted -= m_userAccounts_Changed;
}
if (m_securityGroups != null)
{
m_securityGroups.Saved -= m_securityGroups_Changed;
m_securityGroups.Deleted -= m_securityGroups_Changed;
}
}
finally
{
m_userAccounts = null;
m_securityGroups = null;
m_applicationRoles = null;
}
}
public async Task <IActionResult> Delete(string id)
{
ApplicationRoles role = await roleManager.FindByIdAsync(id);
if (role != null)
{
IdentityResult result = await roleManager.DeleteAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
Errors(result);
}
}
else
{
ModelState.AddModelError("", "No role found");
}
return(View("Index", roleManager.Roles));
}
public string AddEditUserRoles(ApplicationRoles roles, IHttpContextAccessor contextAccessor)
{
try
{
if (roles.Id == 0)
{
ApplicationRoles application = new ApplicationRoles();
application.RoleName = roles.RoleName;
application.Description = roles.Description;
_context.ApplicationRoles.Add(application);
_context.SaveChanges();
}
else
{
_context.ApplicationRoles.Update(roles);
_context.SaveChanges();
}
}
catch (Exception ex)
{
}
return("");
}
public static List <string> GetRoutesByRole(string role)
{
if (string.IsNullOrWhiteSpace(role))
{
role = ApplicationRoles.Public.ToString();
}
ApplicationRoles appRole = (ApplicationRoles)Enum.Parse(typeof(ApplicationRoles), role);
switch (appRole)
{
case ApplicationRoles.SuperAdmin:
return(GetAllRoutes());
case ApplicationRoles.Admin:
return(GetAdminRoutes());
case ApplicationRoles.GeneralUser:
return(GetUserRoutes());
default:
return(GetPublicRoutes());
}
}
public async Task <IActionResult> Create(RegiterViewModelWithRole registertViewModel)
{
try
{
ModelState.Remove("RoleName");
if (ModelState.IsValid)
{
ApplicationUsers applicationUsers = AutoMapper.Mapper.Map <ApplicationUsers>(registertViewModel);
applicationUsers.Id = Guid.NewGuid();
applicationUsers.IsInternalRole = true;
ApplicationRoles roleName = await accountManager.GetRoleByIdAsync(registertViewModel.RoleId.ToString());
(bool result, string[] response) = await accountManager.CreateUserAsync(applicationUsers, new string[] { roleName.Name }, registertViewModel.Password);
if (result)
{
logger.LogInformation($"Successfully Created ${registertViewModel.Email}");
ModelState.AddModelError(EnumAlert.Info.ToString(), "Successfully Created");
return(RedirectToAction(nameof(Index), new { Id = registertViewModel.RoleId }));
}
else
{
logger.LogInformation($"ModelState No Valied ${registertViewModel.Email}${response.JoinError()}");
ModelState.AddModelError(EnumAlert.Info.ToString(), response.JoinError());
return(View(registertViewModel));
}
}
}
catch (Exception ex)
{
logger.LogError(ex, $"Error Occured ${registertViewModel.Email}");
registertViewModel.GetRoles = new RoleHelper(repository).GetRoles(Guid.Empty);
return(View(registertViewModel));
}
registertViewModel.GetRoles = new RoleHelper(repository).GetRoles(Guid.Empty);
return(View(registertViewModel));
}
/// <summary>
/// Creates an instance of <see cref="SecurityUserControl"/> class.
/// </summary>
public SecurityUserControl()
{
ConfigurationFile config;
CategorizedSettingsElementCollection settings;
InitializeComponent();
config = ConfigurationFile.Current;
settings = config.Settings["securityProvider"];
// Set up defaults for config file settings
m_passwordRequirementsRegex = AdoSecurityProvider.DefaultPasswordRequirementsRegex;
m_passwordRequirementsError = AdoSecurityProvider.DefaultPasswordRequirementsError;
// Make sure default config file settings exist
settings.Add("PasswordRequirementsRegex", m_passwordRequirementsRegex, "Regular expression used to validate new passwords for database users.");
settings.Add("PasswordRequirementsError", m_passwordRequirementsError, "Error message to be displayed when new database user password fails regular expression test.");
// Read settings from config file
m_passwordRequirementsRegex = settings["PasswordRequirementsRegex"].ValueAs(m_passwordRequirementsRegex);
m_passwordRequirementsError = settings["PasswordRequirementsError"].ValueAs(m_passwordRequirementsError);
// Initialize view models
m_userAccounts = new UserAccounts(1, false);
m_securityGroups = new SecurityGroups(1, false);
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
// Attach to events
Unloaded += SecurityUserControl_Unloaded;
m_userAccounts.BeforeSave += m_userAccounts_BeforeSave;
m_userAccounts.Saved += m_userAccounts_Changed;
m_userAccounts.Deleted += m_userAccounts_Changed;
m_securityGroups.Saved += m_securityGroups_Changed;
m_securityGroups.Deleted += m_securityGroups_Changed;
}
/// <summary>
/// Creates an instance of <see cref="SecurityUserControl"/> class.
/// </summary>
public SecurityUserControl()
{
ConfigurationFile config;
CategorizedSettingsElementCollection settings;
InitializeComponent();
config = ConfigurationFile.Current;
settings = config.Settings["securityProvider"];
// Set up defaults for config file settings
m_passwordRequirementsRegex = AdoSecurityProvider.DefaultPasswordRequirementsRegex;
m_passwordRequirementsError = AdoSecurityProvider.DefaultPasswordRequirementsError;
// Make sure default config file settings exist
settings.Add("PasswordRequirementsRegex", m_passwordRequirementsRegex, "Regular expression used to validate new passwords for database users.");
settings.Add("PasswordRequirementsError", m_passwordRequirementsError, "Error message to be displayed when new database user password fails regular expression test.");
// Read settings from config file
m_passwordRequirementsRegex = settings["PasswordRequirementsRegex"].ValueAs(m_passwordRequirementsRegex);
m_passwordRequirementsError = settings["PasswordRequirementsError"].ValueAs(m_passwordRequirementsError);
// Initialize view models
m_userAccounts = new UserAccounts(1, false);
m_securityGroups = new SecurityGroups(1, false);
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
// Attach to events
Unloaded += SecurityUserControl_Unloaded;
m_userAccounts.BeforeSave += m_userAccounts_BeforeSave;
m_userAccounts.Saved += m_userAccounts_Changed;
m_userAccounts.Deleted += m_userAccounts_Changed;
m_securityGroups.Saved += m_securityGroups_Changed;
m_securityGroups.Deleted += m_securityGroups_Changed;
}
public ActionResult Index(string Id, string msg = "none")
{
ViewBag.Current = "Roles";
if (Id == null)
{
return(RedirectToAction("BadRequestError", "ErrorController"));
}
RoleManager <ApplicationRoles> manger = new RoleManager <ApplicationRoles>(new RoleStore <ApplicationRoles>(db));
ApplicationRoles role = manger.FindById(Id);
if (role == null)
{
return(RedirectToAction("HttpNotFoundError", "ErrorController"));
}
if (!msg.Equals("none"))
{
ViewBag.Msg = msg;
}
else
{
ViewBag.Msg = null;
}
//Role ID:
Session["Role_Id"] = role.Id;
//Permission Role Informations:
var permissionRoles = db.PermissionRoles.Where(a => a.RoleId.Equals(Id)).Include(p => p.Permission).Include(p => p.Role).Include(a => a.CreatedBy).Include(a => a.UpdatedBy);
return(View(permissionRoles.OrderByDescending(a => a.CreatedAt).ToList()));
}
// PUT: odata/Projects(5)
public IHttpActionResult Put([FromODataUri] int key, Delta <ApplicationRoles> patch)
{
Validate(patch.GetInstance());
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationRoles app = db.ApplicationRoles.Find(key);
if (app == null)
{
return(NotFound());
}
patch.Put(app);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(app));
}
public async Task <(bool, string[])> CreateRoleAsync(ApplicationRoles role, IEnumerable <string> claims)
{
if (claims == null)
{
claims = new string[] { }
}
;
//string[] invalidClaims = claims.Where(c => ApplicationPermissions.GetPermissionByValue(c) == null).ToArray();
//if (invalidClaims.Any())
// return Tuple.Create(false, new[] { "The following claim types are invalid: " + string.Join(", ", invalidClaims) });
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(false, result.Errors.Select(e => e.Description).ToArray());
}
//role = await _roleManager.FindByNameAsync(role.Name);
//foreach (string claim in claims.Distinct())
//{
// result = await this._roleManager.AddClaimAsync(role, new Claim(CustomClaimTypes.Permission, ApplicationPermissions.GetPermissionByValue(claim)));
// if (!result.Succeeded)
// {
// await DeleteRoleAsync(role);
// return Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray());
// }
//}
return(true, new string[] { });
}
private void SecurityUserControl_Unloaded(object sender, RoutedEventArgs e)
{
try
{
if (m_userAccounts != null)
{
m_userAccounts.BeforeSave -= m_userAccounts_BeforeSave;
m_userAccounts.Saved -= m_userAccounts_Changed;
m_userAccounts.Deleted -= m_userAccounts_Changed;
}
if (m_securityGroups != null)
{
m_securityGroups.Saved -= m_securityGroups_Changed;
m_securityGroups.Deleted -= m_securityGroups_Changed;
}
}
finally
{
m_userAccounts = null;
m_securityGroups = null;
m_applicationRoles = null;
}
}
private void m_securityGroups_Changed(object sender, System.EventArgs e)
{
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
}
private void m_securityGroups_Changed(object sender, EventArgs e)
{
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
}
public IActionResult AddEditRoles(ApplicationRoles roles)
{
var result = _account.AddEditUserRoles(roles, _httpContext);
return(new JsonResult("success"));
}
public async Task <bool> IsRoleApplicationRoles(string roleName)
{
ApplicationRoles applicationRoles = await roleManager.FindByNameAsync(roleName);
return(applicationRoles != null);
}
private void m_userAccounts_Changed(object sender, System.EventArgs e)
{
TextBoxPassword.Password = string.Empty;
m_securityGroups = new SecurityGroups(1, false);
m_applicationRoles = new ApplicationRoles(1, true);
RefreshBindings();
}
public static MvcHtmlString AddButton(this HtmlHelper html, string function, string text, ApplicationRoles role)
{
var result = string.Empty;
if (!HttpContext.Current.User.IsInRole(role.ToString()))
{
return(new MvcHtmlString(result));
}
result = $"<a onclick=\"{function}\" class=\"btn btn-sm btn-default\">" +
$"<i class=\"glyphicon glyphicon-plus\"></i> Add {text}</a>";
return(new MvcHtmlString(result));
}
