public async Task <IActionResult> AddEditApplicationRole(string id)
{
if (User.IsInRole("Admin") == false)
{
return(RedirectToAction("Index", "Home"));
}
ApplicationRoleViewModel model = new ApplicationRoleViewModel();
if (!String.IsNullOrEmpty(id))
{
ApplicationRole applicationRole = await _roleManager.FindByIdAsync(id);
if (applicationRole != null)
{
model.Id = applicationRole.Id;
model.RoleName = applicationRole.Name;
model.Description = applicationRole.Description;
}
}
return(View("AddEditApplicationRole", model));
}
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 HttpResponseMessage Update(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var appRole = AppRoleManager.FindById(applicationRoleViewModel.Id);
try
{
appRole.UpdateApplicationRole(applicationRoleViewModel, "update");
AppRoleManager.Update(appRole);
return(request.CreateResponse(HttpStatusCode.OK, appRole));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public IHttpActionResult Create(ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var newAppRole = new AspNetRole();
newAppRole.UpdateApplicationRole(applicationRoleViewModel);
try
{
AppRoleManager.Create(newAppRole);
return(Ok(applicationRoleViewModel));
}
catch (NameDuplicatedException)
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
public HttpResponseMessage Create(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var newAppRole = new AppRole();
newAppRole.UpdateApplicationRole(applicationRoleViewModel);
try
{
AppRoleManager.Create(newAppRole);
return(request.CreateResponse(HttpStatusCode.OK, applicationRoleViewModel));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public IHttpActionResult Update(ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var appRole = AppRoleManager.FindById(applicationRoleViewModel.Id);
try
{
appRole.UpdateApplicationRole(applicationRoleViewModel, "update");
AppRoleManager.Update(appRole);
return(Ok(appRole));
}
catch (NameDuplicatedException)
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
public HttpResponseMessage Update(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var appRole = _appRoleService.GetDetail(applicationRoleViewModel.Id);
try
{
appRole.UpdateApplicationRole(applicationRoleViewModel, "update");
_appRoleService.Update(appRole);
try
{
_appRoleService.Save();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
return(request.CreateResponse(HttpStatusCode.OK, appRole));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public HttpResponseMessage Update(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var appRole = _appRoleService.GetDetail(applicationRoleViewModel.Id);
try
{
appRole.UpdateApplicationRole(applicationRoleViewModel, "update");
_appRoleService.Update(appRole);
_appRoleService.Save();
return request.CreateResponse(HttpStatusCode.OK, appRole);
}
catch (NameDuplicatedException dex)
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message);
}
}
else
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
public async Task <IActionResult> AddEditRole(string id)
{
ApplicationRoleViewModel model = new ApplicationRoleViewModel();
if (!String.IsNullOrEmpty(id))
{
ApplicationRole applicationRole = await _roleManager.FindByIdAsync(id);
if (applicationRole != null)
{
model.Id = applicationRole.Id;
model.Name = applicationRole.Name;
model.Description = applicationRole.Description;
}
else
{
return(RedirectToAction("Index"));
}
}
return(PartialView("_AddEditApplicationRole", model));
}
public async Task <IActionResult> Create(string id, ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id);
ApplicationRole applicationRole = isExist ? await roleManager.FindByIdAsync(id) :
new ApplicationRole
{
CreatedDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
IdentityResult roleRuslt = isExist ? await roleManager.UpdateAsync(applicationRole)
: await roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <IHttpActionResult> AddUpdateGroup([FromBody] ApplicationRoleViewModel role)
{
if (!ModelState.IsValid)
{
throw new Exception("Model not valid");
}
var roleModel = Mapper.Map <ApplicationRole>(role);
roleModel.IsBack = false;
if (role.id > 0)
{
await _applicationRoleService.UpdateApplicationRole(roleModel);
}
else
{
await _applicationRoleService.NewApplicationRole(roleModel);
}
return(Ok(Mapper.Map <ApplicationRoleViewModel>(roleModel)));
}
public ActionResult Permission()
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>());
var principal = HttpContext.User.Identity as ClaimsIdentity;
var userid = principal.GetUserId();
var vm = new List <ApplicationRoleViewModel>();
using (var context = new ApplicationDbContext())
{
var allroles = context.Roles.ToList();
var userClaims = userManager.GetClaims(userid).Select(c => new ApplicationRole
{
Name = c.Value
});
foreach (var role in allroles)
{
var appRole = role as ApplicationRole;
var temp = new ApplicationRoleViewModel
{
Id = appRole.Id,
Description = appRole.Description,
Name = appRole.Name,
RoleGroup = appRole.RoleGroup
};
temp.IsChecked = userClaims.Any(a => a.Name == appRole.Name) ? true : false;
vm.Add(temp);
}
var groupedvm = vm.GroupBy(k => k.RoleGroup).ToList();
return(View(groupedvm));
}
}
public IActionResult AddEditApplicationRole(int id)
{
if (!_accountController)
{
return(RedirectToAction("SignOff", "Account"));
}
ApplicationRoleViewModel model = new ApplicationRoleViewModel();
if (id > 0)
{
//ApplicationRole applicationRole = await roleManager.FindByIdAsync(id);
ApplicationRole applicationRole = _db.Roles.Where(r => r.Id == id).FirstOrDefault();
if (applicationRole != null)
{
model.Id = applicationRole.Id;
model.RoleName = applicationRole.Name;
model.Description = applicationRole.Description;
}
}
return(PartialView("_AddEditApplicationRole", model));
}
public IActionResult Create(ApplicationRoleViewModel ApplicationRole)
{
if (ModelState.IsValid)
{
int exists = (from m in
_unitOfWork.ApplicationRoleRepo.GetAll().Where(
a => a.Name.ToLower() == ApplicationRole.Name.ToLower() &&
a.IsDeleted == false)
select m).Count();
if (exists > 0)
{
ApplicationRole.MessageText = Notification.Show("Already Exixts", "Role", ToastType.Warning);
}
else
{
ApplicationRole application = new ApplicationRole();
application.Name = ApplicationRole.Name;
application.NormalizedName = ApplicationRole.Name.ToUpper();
application.EntryBy = 1;
application.EntryDate = Convert.ToDateTime(DateTime.Now.ToString("dd-MM-yyyy"));
application.UpdatedDate = Convert.ToDateTime(DateTime.Now.ToString("dd-MM-yyyy"));
_unitOfWork.ApplicationRoleRepo.Add(application);
_unitOfWork.Save();
ApplicationRole.MessageText = Notification.Show("Save successfully", "Role", ToastType.Warning);
//////////////////////////Using Identity Role Management/////////////////////////////////////
//var result = await _roleManager.CreateAsync(ApplicationRole);
//if (result.Succeeded)
//{
// _logger.LogInformation("Role created.");
// return RedirectToAction(nameof(Index));
//}
//AddErrors(result);
//////////////////////////////////////////////////////////////////////////////////////////////
}
}
return(View(ApplicationRole));
}
public async Task <bool> CreateRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
{
data.CreatedBy = ExtBusinessLogic.UserValue(claim);
data.ModifiedBy = ExtBusinessLogic.UserValue(claim);
ApplicationRole roleData = _mapper.Map <ApplicationRole>(data);
bool roleExist = await _roleManager.RoleExistsAsync(roleData.Name);
if (roleExist)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.RoleAlreadyExist);
}
roleData.GenerateNewId();
var result = await _roleManager.CreateAsync(roleData);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
}
return(true);
}
public async Task <IActionResult> UpdateRole(ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(model.Id);
ApplicationRole applicationRole = isExist ? await _roleManager.FindByIdAsync(model.Id) :
new ApplicationRole
{
CreateDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
applicationRole.IpAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
IdentityResult roleRuslt = await _roleManager.UpdateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public HttpResponseMessage Add(HttpRequestMessage request, ApplicationRoleViewModel appRoleVm)
{
return(CreateHttpResponse(request, () =>
{
if (ModelState.IsValid)
{
HttpResponseMessage response = null;
var newRole = new AppRole();
newRole.UpdateRole(appRoleVm);
newRole.Id = Guid.NewGuid().ToString();//sinh ngẫu nhiên id
_appRoleService.Add(newRole);
_appRoleService.Save();
var modelVm = Mapper.Map <AppRole, ApplicationRoleViewModel>(newRole);
response = request.CreateResponse(HttpStatusCode.OK, modelVm);
return response;
}
else
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}));
}
public async Task <ActionResult> Create([Bind(Include = "Name")] ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
ApplicationRole applicationRole = new ApplicationRole {
Name = applicationRoleViewModel.Name
};
var roleResult = await RoleManager.CreateAsync(applicationRole);
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", roleResult.Errors.First());
return(View());
}
//db.IdentityRoles.Add(applicationRole);
//await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(applicationRoleViewModel));
}
public async Task <IActionResult> AddEditApplicationRole(string Id, ApplicationRoleViewModel model, string redirecturl)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(Id);
ApplicationRole applicationRole = isExist ? await _roleManager.FindByIdAsync(Id) :
new ApplicationRole //insert
{
};
applicationRole.Name = model.Name;
applicationRole.Description = model.Description;
IdentityResult roleresult = isExist ? await _roleManager.UpdateAsync(applicationRole) :
await _roleManager.CreateAsync(applicationRole);
if (roleresult.Succeeded)
{
return(PartialView("_Succefullyresponse", redirecturl));
}
}
return(PartialView("AddEditApplicationRole", model));
}
public async Task <IActionResult> AddEditApplicationRole(string id, [FromBody] ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id);
ApplicationRole applicationRole = isExist ? await roleManager.FindByIdAsync(id) :
new ApplicationRole
{
CreatedDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
applicationRole.IPAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
IdentityResult roleRuslt = isExist ? await roleManager.UpdateAsync(applicationRole)
: await roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(Ok(new { Success = false, message = "Successfully Add/Edit application role" }));
}
}
return(BadRequest(new { Success = false, message = "Failed to Add/Edit application role" }));
}
public async Task <IActionResult> AddEditApplicationRole(string id, ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id);
IdentityRole applicationRole = isExist ? await roleManager.FindByIdAsync(id) :
new IdentityRole
{
//CreatedDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
/* applicationRole.Description = model.Description;
* applicationRole.IPAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();*/
IdentityResult roleRuslt = isExist ? await roleManager.UpdateAsync(applicationRole)
: await roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddEditRole(string id, ApplicationRoleViewModel model, string redirectUrl)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id); // !
ApplicationRole applicationrole = isExist ? await _irs.FindByIdAsync(id) : new ApplicationRole
{
// insert
};
applicationrole.Name = model.Name;
applicationrole.Description = model.Description;
IdentityResult roleResult = isExist ? await _irs.updateAsync(applicationrole) :
await _irs.createAsync(applicationrole);
if (roleResult.Succeeded)
{
return(PartialView("_succesfullyresponse", redirectUrl));
}
}
return(PartialView("_AddEditApplicationRole", model));
}
public async Task <ActionResult> Edit([Bind(Include = "id,Name")] ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
ApplicationRole retrievedApplicationRole = await RoleManager.FindByIdAsync(applicationRoleViewModel.Id);
string originalName = retrievedApplicationRole.Name;
if (originalName == "Admin" && applicationRoleViewModel.Name != "Admin")
{
ModelState.AddModelError("", "You cant change the name of admin role..");
return(View(applicationRoleViewModel));
}
if (originalName != "Admin" && applicationRoleViewModel.Name == "Admin")
{
ModelState.AddModelError("", "You cant change the name of a role to admin role..");
return(View(applicationRoleViewModel));
}
retrievedApplicationRole.Name = applicationRoleViewModel.Name;
await RoleManager.UpdateAsync(retrievedApplicationRole);
return(RedirectToAction("Index"));
}
return(View(applicationRoleViewModel));
}
public async Task <IActionResult> Edit(ApplicationRoleViewModel modifyRole)
{
IdentityResult result;
if (ModelState.IsValid)
{
IdentityRole role = await roleManager.FindByIdAsync(modifyRole.Id);
role.Name = modifyRole.Name;
result = await roleManager.UpdateAsync(role);
if (!result.Succeeded)
{
AddErrors(result);
}
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
return(View(modifyRole.Id));
}
public HttpResponseMessage Create(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
try
{
var newApplicationRole = new ApplicationRole();
newApplicationRole.Name = applicationRoleViewModel.Name;
newApplicationRole.Description = applicationRoleViewModel.Description;
var applicationRole = this._applicationRoleService.Add(newApplicationRole);
this._applicationRoleService.Save();
return(request.CreateResponse(HttpStatusCode.OK, applicationRoleViewModel));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <HttpResponseMessage> Create(HttpRequestMessage request, ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
var newAppRole = new ApplicationRole();
newAppRole.UpdateApplicationRole(applicationRoleViewModel);
try
{
await _appRoleService.Add(newAppRole);
await _appRoleService.Save();
return(request.CreateResponse(HttpStatusCode.OK, applicationRoleViewModel));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <IActionResult> Edit(string id, ApplicationRoleViewModel input)
{
if (ModelState.IsValid)
{
var roleToUpdate = await _roleManager.FindByIdAsync(id);
if (await TryUpdateModelAsync(roleToUpdate))
{
await _roleManager.SetRoleNameAsync(roleToUpdate, input.Name);
var result = await _roleManager.UpdateAsync(roleToUpdate);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View());
}
public async Task <IActionResult> Post(string id, [FromBody] ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id);
AppRole applicationRole = isExist ? await _roleManager.FindByIdAsync(id) :
new AppRole
{
CreatedDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
applicationRole.IPAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
IdentityResult roleRuslt = isExist ? await _roleManager.UpdateAsync(applicationRole)
: await _roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
// return RedirectToAction("Index");
return(new OkObjectResult("Role Created"));
}
}
return(await Task.FromResult <IActionResult>(null));
}
public async Task <IActionResult> AddEditApplicationRole(string id, ApplicationRoleViewModel model)
{
if (ModelState.IsValid)
{
bool isExist = !String.IsNullOrEmpty(id);
ApplicationRole applicationRole = isExist ? await roleManager.FindByIdAsync(id) :
new ApplicationRole
{
CreatedDate = DateTime.Now
};
sp_Logging("2-Change", "Add/Edit", "Successfuly added or edited a Role", "Success");
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
applicationRole.IPAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
IdentityResult roleRuslt = isExist ? await roleManager.UpdateAsync(applicationRole)
: await roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <ActionResult> Edit(int id, ApplicationRoleViewModel applicationRoleViewModel)
{
try
{
EditViewBagParams();
if (id <= 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
ApplicationRole applicationRole = await RoleManager.FindByIdAsync(applicationRoleViewModel.Id);
string originalName = applicationRole.Name;
if (originalName == "PortalAdmin" && applicationRoleViewModel.Name != "PortalAdmin")
{
ModelState.AddModelError("", "You cannot change the name of the Portal Admin role.");
return(PartialView("_PartialAddEdit", applicationRoleViewModel));
}
if (originalName != "PortalAdmin" && applicationRoleViewModel.Name == "PortalAdmin")
{
ModelState.AddModelError("", "You cannot change the name of a role to Portal Admin.");
return(PartialView("_PartialAddEdit", applicationRoleViewModel));
}
applicationRole.Name = applicationRoleViewModel.Name;
await RoleManager.UpdateAsync(applicationRole);
_rolePermissionyQuery.ExecuteStoreprocedure("DeletePermissionByRoleID @RoleId", new SqlParameter("RoleId", applicationRole.Id));
if (applicationRoleViewModel.SelectedPermissionId != null && applicationRoleViewModel.SelectedPermissionId.Any())
{
foreach (var permissionId in applicationRoleViewModel.SelectedPermissionId)
{
_rolePermissionCommand.Insert(new RolePermission()
{
RoleId = applicationRole.Id,
PermissionId = permissionId,
});
_rolePermissionCommand.SaveChanges();
}
}
_activityRepo.CreateActivityLog(string.Format("updated Portal Role with Name:{0}", applicationRole.Name), this.GetContollerName(), this.GetContollerName(), User.Identity.GetUserId <Int64>(), applicationRole);
TempData["MESSAGE"] = "Portal Role " + applicationRole.Name + " was successfully updated";
ModelState.Clear();
return(Json(new { success = true }));
}
else
{
StringBuilder errorMsg = new StringBuilder();
foreach (var modelError in ModelState.Values.SelectMany(modelState => modelState.Errors))
{
errorMsg.AppendLine(modelError.ErrorMessage);
ModelState.AddModelError(string.Empty, modelError.ErrorMessage);
}
ViewBag.ErrMsg = errorMsg.ToString();
return(PartialView("_PartialAddEdit", applicationRoleViewModel));
}
}
catch (Exception exp)
{
_log.Error(exp);
return(View("Error"));
}
}
private void LoadData()
{
_reader = new PackageReader();
_reader.Read(PathToFile);
PackageViewModel = new PackageViewModel(_reader);
MetadataViewModel = new MetadataViewModel(_reader);
ManifestViewModel = new ManifestViewModel(_reader);
RequiresViewModel = new RequiresViewModel(_reader);
DefineViewModel = new DefineViewModel(_reader);
SigningViewModel = new SigningViewModel(_reader);
LicenseViewModel = new LicenseViewModel(_reader);
CompatibilityPolicy = new CompatibilityPolicyViewModel(_reader);
ApplicationRoleViewModel = new ApplicationRoleViewModel(_reader);
AssemblyRoleViewModel = new AssemblyRoleViewModel(_reader);
FilesViewModel = new FilesViewModel(_reader);
//PackageCompositionViewModel = new PackageCompositionViewModel(_reader);
//_allViewModels.Add(PackageViewModel);
}
