public async Task <IActionResult> CreateRole(RoleCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var result = await this._roleManager.CreateAsync(this._mapper.Map <IdentityRole>(viewModel));
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
return(View(viewModel));
}
}
return(RedirectToAction(nameof(ListRoles)));
}
catch (DbUpdateException ex)
{
this._logger.LogError(ex.Message);
return(View("Error", new ErrorViewModel()
{
ErrorTitle = "Create Role", ErrorMessage = ex.Message
}));
}
}
return(View(viewModel));
}
public IHttpActionResult Create(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (model.Name.Trim().Length <= 0)
{
response.SetFailed("请输入角色名称");
return(Ok(response));
}
using (_dbContext)
{
// if (_dbContext.Roles.Count(x => x.Name == model.Name) > 0) {
if (_dbContext.Roles.Any(x => x.Name == model.Name))
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = _mapper.Map <RoleCreateViewModel, Role>(model);
entity.CreatedOn = DateTime.Now;
entity.Code = RandomHelper.GetRandomizer(8, true, false, true, true);
entity.IsSuperAdministrator = false;
entity.IsBuiltin = false;
entity.CreatedByUserId = AuthContextService.CurrentUser.UserId;
entity.CreatedByUserName = AuthContextService.CurrentUser.DisplayName;
_dbContext.Roles.Add(entity);
_dbContext.SaveChanges();
response.SetSuccess();
return(Ok(response));
}
}
public async Task <IActionResult> AddRole(RoleCreateViewModel role)
{
if (!ModelState.IsValid)
{
return(View(role));
}
else
{
var _role = new IdentityRole {
Name = role.RoleName
};
var result = await _roleManager.CreateAsync(_role);
if (result.Succeeded)
{
// return View("Index");
return(RedirectToAction("Index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(role));
}
public IActionResult Edit(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
using (_dbContext)
{
if (_dbContext.DncRole.Count(x => x.Name == model.Name && x.Id != model.Id) > 0)
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = _dbContext.DncRole.FirstOrDefault(x => x.Id == model.Id);
if (entity.IsSuperAdministrator && !AuthContextService.IsSupperAdministator)
{
response.SetFailed("没有足够的权限");
return(Ok(response));
}
entity.Name = model.Name;
entity.IsDeleted = model.IsDeleted;
entity.ModifiedByUserId = AuthContextService.CurrentUser.Id;
entity.ModifiedByUserName = AuthContextService.CurrentUser.DisplayName;
entity.ModifiedOn = DateTime.Now;
entity.Status = model.Status;
entity.Description = model.Description;
_dbContext.SaveChanges();
return(Ok(response));
}
}
public async Task <IActionResult> CreateRole(RoleCreateViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("index", "home"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> Create(RoleCreateViewModel role)
{
if (ModelState.IsValid)
{
var roleCheck = await _roleManager.RoleExistsAsync(role.Name);
if (!roleCheck)
{
IdentityRole newRole = new IdentityRole
{
Name = role.Name
};
IdentityResult roleResult = await _roleManager.CreateAsync(newRole);
return(RedirectToAction("index", "Roles"));
}
else
{
ModelState.AddModelError("Name", "Role with given name already exists.");
}
}
return(View(role));
}
public async Task <IActionResult> Create(RoleCreateViewModel model)
{
var departments = EnumExtensions.GetExtendedValues(typeof(EDepartment));
model.Departments = departments
.Where(d => d.Name != EDepartment.None.ToString())
.Select(d => new SelectListItem()
{
Text = d.DisplayName,
Value = d.Name
}).OrderBy(i => i.Text);
if (await roleService.RoleExistsAsync(model.Name))
{
ViewData[ErrorKey] = string
.Format(ObjectExistsErrorMessage, $"Role '{model.Name}'");
return(View(model));
}
var role = mapper.Map <Role>(model);
var createResult = await roleService.CreateAsync(role);
if (!createResult.Succeeded)
{
ViewData[ErrorKey] = createResult.Errors.Select(e => e.Description);
return(View(model));
}
var departmentClaim = new Claim(DepartmentKey, role.Department.ToString());
await roleService.AddClaimAsync(role, departmentClaim);
logger.LogInformation($"'{User.Identity.Name}' created role '{role.Name}'.");
ViewData[InfoKey] = $"Role '{role.Name}' created successfully.";
await employeeService.UpdateLastWorkedAsync(User.GetId());
return(View(model));
}
public async Task <IActionResult> CreateRole(RoleCreateViewModel model)
{
if (ModelState.IsValid)
{
// We just need to specify a unique role name to create a new role
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
// Saves the role in the underlying AspNetRoles table
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administration"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public IActionResult Edit(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (ConfigurationManager.AppSettings.IsTrialVersion)
{
response.SetIsTrial();
return(Ok(response));
}
using (_dbContext)
{
if (_dbContext.SystemRole.Count(x => x.RoleName == model.RoleName && x.SystemRoleUuid != model.SystemRoleUuid) > 0)
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = _dbContext.SystemRole.FirstOrDefault(x => x.SystemRoleUuid == model.SystemRoleUuid);
entity.RoleName = model.RoleName;
int res = _dbContext.SaveChanges();
if (res > 0)
{
ToLog.AddLog("编辑", "成功:编辑:系统角色管理列表数据", _dbContext);
}
return(Ok(response));
}
}
public IActionResult Create(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (model.RoleName.Trim().Length <= 0)
{
response.SetFailed("请输入角色名称");
return(Ok(response));
}
using (_dbContext)
{
if (_dbContext.SystemRole.Count(x => x.RoleName == model.RoleName) > 0)
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = new SystemRole();
entity.SystemRoleUuid = Guid.NewGuid();
entity.RoleName = model.RoleName;
entity.AddTime = DateTime.Now.ToString("yyyy-MM-dd");
entity.AddPeople = AuthContextService.CurrentUser.DisplayName;
entity.IsDeleted = 0;
_dbContext.SystemRole.Add(entity);
_dbContext.SaveChanges();
response.SetSuccess();
return(Ok(response));
}
}
public async Task <ActionResult> Create(RoleCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IdentityResult result = await RoleManager.CreateAsync(new Role(model.Name) { Description = model.Description });
if (result.Succeeded)
{
foreach (string userId in model.UserIdsToAdd ?? new string[] { })
{
result = await UserManager.AddToRoleAsync(userId, model.Name);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
return(View(model));
}
}
return(RedirectToAction("Index"));
}
AddErrorsFromResult(result);
return(View(model));
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
public async Task CreateByViewModelAsync(RoleCreateViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
var role = _mapper.Map <Role>(viewModel);
role.Code = await GenerateCodeAsync();
var permissionIds = viewModel.Permissions.Split(',');
role.RolePermissions = new HashSet <RolePermission>();
permissionIds.ForEach(permissionId => role.RolePermissions.Add(new RolePermission {
PermissionId = permissionId.ToGuidOrDefault()
}));
role.CreatedById = _httpContextManager.CurrentUserId();
role.CreatedOn = DateTime.Now;
_roleRepository.Add(role);
await _unitOfWork.SaveAllChangesAsync();
_eventPublisher.EntityInserted(role);
}
public async Task <ActionResult <ResponseModel> > Create(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (model.Name.Trim().Length <= 0)
{
response.SetFailed("请输入角色名称");
return(Ok(response));
}
await using (_dbContext)
{
if (_dbContext.DncRole.Count(x => x.Name == model.Name) > 0)
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = _mapper.Map <RoleCreateViewModel, DncRole>(model);
entity.CreatedOn = DateTime.Now;
entity.Code = RandomHelper.GetRandomizer(8, true, false, true, true);
entity.IsSuperAdministrator = false;
entity.IsBuiltin = false;
entity.CreatedByUserGuid = AuthContextService.CurrentUser.Guid;
entity.CreatedByUserName = AuthContextService.CurrentUser.DisplayName;
await _dbContext.DncRole.AddAsync(entity);
await _dbContext.SaveChangesAsync();
response.SetSuccess();
return(Ok(response));
}
}
public async Task <IActionResult> Create([FromForm] RoleCreateViewModel vmItem)
{
// Invalid model
if (!ModelState.IsValid)
{
return(View(vmItem));
}
// Get time stamp for table to handle concurrency conflict
var tableName = nameof(AspNetRoles);
var tableVersion = await _context.TableVersion.FirstOrDefaultAsync(h => h.Id == tableName);
// Trim white space
// Create save db item
var dbItem = new AspNetRoles
{
Id = Guid.NewGuid().ToString(),
Name = vmItem.Name,
NormalizedName = vmItem.NormalizedName,
ConcurrencyStamp = vmItem.ConcurrencyStamp,
};
_context.Add(dbItem);
// Set time stamp for table to handle concurrency conflict
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { id = dbItem.Id }));
}
public IActionResult Create(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (model.Name.Trim().Length <= 0)
{
response.SetFailed("请输入角色名称");
return(Ok(response));
}
using (_dbContext)
{
if (_dbContext.DncRole.Count(x => x.Name == model.Name) > 0)
{
response.SetFailed("角色已存在");
return(Ok(response));
}
var entity = _mapper.Map <RoleCreateViewModel, DncRole>(model);
entity.CreatedOn = DateTime.Now;
entity.Code = RandomHelper.GetRandomizer(8, true, false, true, true);
entity.CreatedByUserId = 1;
entity.CreatedByUserName = "******";
_dbContext.DncRole.Add(entity);
_dbContext.SaveChanges();
response.SetSuccess();
return(Ok(response));
}
}
public ActionResult Create()
{
var model = new RoleCreateViewModel {
Users = UserManager.Users.ToList()
};
return(View(model));
}
// GET: Role/Create
public ActionResult Create()
{
var roleCreateViewModel = new RoleCreateViewModel {
Permissions = PopulatePermissions()
};
return(View(roleCreateViewModel));
}
public void Should_Not_Create_New_Role_With_Admin_Name()
{
var viewModel = new RoleCreateViewModel
{
Name = "Admin"
};
Assert.Throws <DbUpdateException>(() => _roleService.Create(viewModel));
}
public ActionResult <RoleViewModel> Create([FromBody] RoleCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUserId = User.Claims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
return(_mapper.Map <RoleViewModel>(_roleService.CreateRole(_mapper.Map <RoleCreateDTO>(model), currentUserId)));
}
public async Task <IActionResult> CreateRole(int teamId)
{
USER user = await _userRepository.GetUserByContext(HttpContext.User);
if (_permissionService.CheckPermissionToManageUsers(user, teamId))
{
RoleCreateViewModel model = new RoleCreateViewModel {
TeamId = teamId
};
return(View(model));
}
return(RedirectToAction("AccessDenied", "Account"));
}
public ActionResult Create()
{
if (!Services.Authorizer.Authorize(Permissions.ManageRoles, T("Not authorized to manage roles")))
{
return(new HttpUnauthorizedResult());
}
var model = new RoleCreateViewModel {
FeaturePermissions = _roleService.GetInstalledPermissions()
};
return(View(model));
}
public async Task <IActionResult> Create(RoleCreateViewModel model)
{
if (ModelState.IsValid)
{
var identityRole = _mapper.Map <VesizleRole>(model);
var identityResult = await _roleManager.CreateAsync(identityRole);
if (identityResult.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
private static List <RoleFunctions> BuildRoleFunctions(RoleCreateViewModel model, Role entity)
{
var roleFunctions = new List <RoleFunctions>();
if (model.Functions != null && model.Functions.Length > 0)
{
model.Functions.ToList().ForEach(x => roleFunctions.Add(new RoleFunctions
{
RoleId = entity.Id,
FunctionCode = x
}));
}
return(roleFunctions);
}
public async Task <IActionResult> Create(RoleCreateViewModel newRoleModel)
{
if (!ModelState.IsValid)
{
return(View());
}
if (!_roleManager.RoleExistsAsync(newRoleModel.Name).Result)
{
IdentityRole rol = new IdentityRole();
rol.Name = newRoleModel.Name;
var roleResult = await _roleManager.CreateAsync(rol);
}
return(RedirectToAction("Index"));
}
public void Should_Create_New_Role(string role)
{
var viewModel = new RoleCreateViewModel
{
Name = role
};
_roleService.Create(viewModel);
using (var context = IoC.Resolve <IUnitOfWork>())
{
var user = context.Set <Role>().FirstOrDefault(a => a.Name == role);
user.ShouldNotBeNull();
}
}
public IActionResult Create()
{
var departments = EnumExtensions.GetExtendedValues(typeof(EDepartment));
var model = new RoleCreateViewModel()
{
Departments = departments
.Where(d => d.Name != EDepartment.None.ToString())
.Select(d => new SelectListItem()
{
Text = d.DisplayName,
Value = d.Name
}).OrderBy(i => i.Text)
};
return(View(model));
}
public async Task <IActionResult> Create(RoleCreateViewModel model)
{
AppRole role = new AppRole
{
Name = model.Name,
ConcurrencyStamp = model.ConcurrencyStamp,
NormalizedName = model.NormalizedName
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(View());
}
return(View());
}
public ActionResult Create(RoleCreateViewModel model)
{
try
{
// TODO: Add insert logic here
IdentityRole role = new IdentityRole();
role.Name = model.RoleName;
context.Roles.Add(role);
context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult Edit(RoleCreateViewModel model)
{
var response = ResponseModelFactory.CreateInstance;
if (ConfigurationManager.AppSettings.IsTrialVersion)
{
response.SetIsTrial();
return(Ok(response));
}
using (_dbContext)
{
var rEntity = _dbContext.SystemRole.FirstOrDefault(x => x.SystemRoleUuid == model.SystemRoleUuid);
if (rEntity == null)
{
response.SetFailed("角色不存在");
return(Ok(response));
}
else
{
if (AuthContextService.CurrentUser.SchoolGuid == null)
{
if (_dbContext.SystemRole.Any(x => x.RoleName == model.RoleName))
{
response.SetFailed("角色已存在");
return(Ok(response));
}
}
else
{
if (_dbContext.SystemRole.Any(x => x.RoleName == model.RoleName && x.SchoolUuid == AuthContextService.CurrentUser.SchoolGuid))
{
response.SetFailed("角色已存在");
return(Ok(response));
}
}
}
var entity = _dbContext.SystemRole.FirstOrDefault(x => x.SystemRoleUuid == model.SystemRoleUuid);
entity.RoleName = model.RoleName;
entity.SchoolUuid = model.SchoolUuid;
_dbContext.SaveChanges();
return(Ok(response));
}
}
public void CreateRole(RoleCreateViewModel roleModel)
{
ROLE role = new ROLE
{
NAME = roleModel.RoleName,
DESCRIPTION = roleModel.RoleDescription,
TEAM_ID = roleModel.TeamId,
IS_REQUIRED = false,
IS_TEAM_OWNER = false,
CAN_ASSIGN_TASK = roleModel.CanAssignTask,
CAN_COMMENT = roleModel.CanComment,
CAN_CREATE_TASK = roleModel.CanCreateTask,
CAN_MANAGE_USERS = roleModel.CanManageUsers
};
_roleRepository.AddRole(role);
}
