public async Task <ActionResult> Create([FromBody] RoleCreateModel roleModel,
[FromServices] IValidatorFactory validatorFactory,
[FromServices] ICreateRoleCommand createRoleCommand)
{
try
{
if (roleModel == null)
{
return(BadRequest());
}
IValidator validator = validatorFactory.Create();
string roleId = await createRoleCommand.Execute(roleModel, validator);
if (validator.HasErrors)
{
return(BadRequest(validator.Errors));
}
else
{
return(Created("", roleId));
}
}
catch (Exception ex)
{
//Log error
_logger.LogError("RoleController.Create", "Exception was thrown.", new
{
RoleModel = roleModel,
Exception = ex
});
return(BadRequest(new Message("Something bad happened. Try again.")));
}
}
public async Task <IActionResult> RoleCreate(RoleCreateModel model)
{
if (ModelState.IsValid)
{
var result = await _RoleManager.CreateAsync(new IdentityRole(model.Name));
if (result.Succeeded)
{
TempData.Put("message", new AlertMessage()
{
Title = "Success",
Message = $"The role {model.Name} has been created.",
AlertType = "success"
});
return(Redirect("/admin/rolelist"));
}
else
{
foreach (var errorLog in result.Errors)
{
ModelState.AddModelError("", errorLog.Description);
}
}
return(View(model));
}
return(View(model));
}
public async Task <IActionResult> AddRole(RoleCreateModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _roleService.CreateRoleAsync(model);
return(RedirectToAction(nameof(IndexRole)));
}
public ActionResult Create(RoleCreateModel model)
{
if (!ModelState.IsValid)
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = MVCHelper.GetValidMsg(ModelState)
}));
}
long roleId = RoleService.AddNew(model.Name);
PermService.AddPermIds(roleId, model.permissionIds);
return(Json(new AjaxResult {
Status = "ok"
}));
}
public async Task <IActionResult> CreateRole(RoleCreateModel model)
{
if (ModelState.IsValid && !roleManager.RoleExistsAsync(model.Name).GetAwaiter().GetResult())
{
var result = await roleManager.CreateAsync(new IdentityRole(model.Name));
if (result.Succeeded)
{
return(RedirectToAction("Roles"));
}
else
{
AddErrorsFromResult(result);
}
}
return(View(model));
}
public Result Create(RoleCreateModel model)
{
var result = new Result();
var roles = _roleRepository.GetAll();
var userInputRole = model.Name;
foreach (Role role in roles)
{
if (role.Name == userInputRole)
{
result.Success = false;
result.Message = "This role already exists";
return(result);
}
}
try
{
var role = new Role()
{
Name = model.Name,
IsActive = model.IsActive
};
//TODO: CryptoHelperdan parola cryptolanacak
role.InsertedDate = DateTime.Now;
_roleRepository.Create(role);
result.Success = true;
result.Message = "Role was created succesfully";
}
catch (Exception ex)
{
result.Success = false;
result.Message = "It has a an error when creating role " + ex.Message;
}
return(result);
}
public IHttpActionResult CreateRole(RoleCreateModel role)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RoleDTO newRole = new RoleDTO
{
Name = role.RoleName
};
try
{
RoleService.Create(newRole);
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
return(CreatedAtRoute("DefaultApi", new { id = newRole.Id }, newRole));
}
public async Task <ActionResult> Edit([FromRoute] string roleId,
[FromBody] RoleCreateModel changes,
[FromServices] IValidatorFactory validatorFactory,
[FromServices] IEditRoleCommand editRoleCommand)
{
try
{
if (roleId == null || changes == null)
{
return(BadRequest());
}
IValidator validator = validatorFactory.Create();
await editRoleCommand.Execute(roleId, changes, validator);
if (validator.HasErrors)
{
return(BadRequest(validator.Errors));
}
else
{
return(Created("", roleId));
}
}
catch (Exception ex)
{
//Log error
_logger.LogError("RoleController.Edit", "Exception was thrown", new
{
RoleId = roleId,
Changes = changes,
Exception = ex
});
return(BadRequest(new Message("Something bad happened. Try again")));
}
}
public async Task <string> Execute(RoleCreateModel roleModel, IValidator validator)
{
try
{
// Validate fields.
_validationStrategy.Validate(roleModel, validator);
if (validator.HasErrors)
{
return(null);
}
// Check if role with this name and consumer already exists.
long count = await _roleRepo.CountDocumentsAsync(x => x.Name == roleModel.Name && x.Consumer == roleModel.Consumer);
if (count != 0)
{
validator.AddError("A role with this name already exists");
return(null);
}
// Create role entity.
Role role = new Role()
{
Id = roleModel.Id,
Name = roleModel.Name,
Description = roleModel.Description,
Consumer = roleModel.Consumer,
Status = roleModel.Status
};
// Persist created role.
await _roleRepo.InsertOneAsync(role);
// Issue an event describing the created role.
await Publish(new RoleCreatedOrEditedEvent()
{
CorrelationId = Guid.NewGuid().ToString("N"),
IssuerSystem = "AuthServer.UserSystem",
Issuer = "AuthServer.UserSystem.Services.Commands.CreateRoleCommand",
EventDate = DateTime.Now,
Id = role.Id,
Name = role.Name,
Description = role.Description,
Consumer = role.Consumer,
RoleIsActive = (role.Status == RoleStatus.Active)
});
// Return role id.
return(role.Id);
}
catch (Exception ex)
{
//Log error
await _logger.LogErrorAsync("CreateRoleCommand.Execute", "Exception was thrown", new
{
RoleModel = roleModel,
Exception = ex
});
throw;
}
}
public async Task Execute(string roleId, RoleCreateModel changes, IValidator validator)
{
try
{
//Validate fields
_validationStrategy.Validate(changes, validator);
if (validator.HasErrors)
{
return;
}
//Check if role with this name and consumer already exists
long count = await _roleRepo.CountDocumentsAsync(x => x.Name == changes.Name && x.Consumer == changes.Consumer && x.Id != roleId);
if (count != 0)
{
validator.AddError("A role with this name already exists");
return;
}
IAsyncCursor <Role> cursor = await _roleRepo.FindAsync(x => x.Id == roleId);
Role role = await cursor.SingleOrDefaultAsync();
if (role == null)
{
throw new Exception("Role not found");
}
var updateDef = Builders <Role> .Update.Set(r => r.Name, changes.Name)
.Set(r => r.Description, changes.Description)
.Set(r => r.Consumer, changes.Consumer)
.Set(r => r.Status, changes.Status);
//Persist created role
await _roleRepo.UpdateOneAsync(r => r.Id == roleId, updateDef);
await Publish(new RoleCreatedOrEditedEvent()
{
CorrelationId = Guid.NewGuid().ToString("N"),
IssuerSystem = "AuthServer.UserSystem",
Issuer = "AuthServer.UserSystem.Services.Commands.EditRoleCommand",
EventDate = DateTime.Now,
Id = role.Id,
Name = role.Name,
Description = role.Description,
Consumer = role.Consumer,
RoleIsActive = (role.Status == RoleStatus.Active)
});
return;
}
catch (Exception ex)
{
//Log error
await _logger.LogErrorAsync("EditRoleCommand.Execute", "Exception was thrown", new
{
RoleId = roleId,
Changes = changes,
Exception = ex
});
throw;
}
}
public Result Post([FromBody] RoleCreateModel userCreateModel)
{
return(_roleService.Create(userCreateModel));
}
public async Task <Result> CreateRoleAsync(RoleCreateModel model)
{
return(await _roleManagerService.CreateRoleAsync(model.Name));
}
public async Task <IActionResult> CreateRole([FromBody] RoleCreateModel model)
{
var result = new Result();
var role = new ApplicationRole();
var loggedInUser = await GetUser();
IdentityResult IdResult = null;
try
{
if (!ModelState.IsValid)
{
return(BadRequest(new {
Errors = new SerializableError(ModelState),
Success = false
}));
}
var roleToCreate = model.RoleName + "-" + _key.Substring(0, 12);
if (model.Claims == null)
{
model.Claims = new string[] { }
}
;
var invalidClaims = model.Claims.Where(c => _uow.Permissions.GetAllPermissions().Where(x => x.Value.ToLowerInvariant() == c.ToLowerInvariant()) == null).ToArray();
if (invalidClaims.Any())
{
result = new Result()
{
Success = false,
Errors = new[] { "The following claim types are invalid: " + string.Join(", ", invalidClaims) },
Data = null
};
return(BadRequest(result));
}
if (!(await _roleManager.RoleExistsAsync(roleToCreate)))
{
role = new ApplicationRole
{
Name = roleToCreate.Trim().ToLowerInvariant(),
DisplayName = model.RoleName,
CreatedBy = loggedInUser.Id,
SharedKey = _key,
IsActive = true,
IsDeleted = false,
CreatedDate = DateTime.Now,
};
IdResult = await _roleManager.CreateAsync(role);
if (!IdResult.Succeeded)
{
result = new Result()
{
Success = false,
Errors = IdResult.Errors.Select(e => e.Description).ToArray(),
Data = null
};
return(BadRequest(result));
}
role = await _roleManager.FindByNameAsync(role.Name);
foreach (string claim in model.Claims.Distinct())
{
IdResult = await this._roleManager.AddClaimAsync(role, new Claim(claim, claim));
if (!IdResult.Succeeded)
{
await DeleteRoleAsync(role);
result = new Result()
{
Success = false,
Errors = IdResult.Errors.Select(e => e.Description).ToArray(),
};
return(BadRequest(result));
}
}
}
else
{
result.AddError("Role already exists");
return(BadRequest(result));
}
result = new Result
{
Success = true,
Data = new
{
role.Id,
Role = model.RoleName,
model.Claims
}
};
return(Ok(result));
}
catch (Exception ex)
{
await DeleteRoleAsync(role);
result = new Result()
{
Success = false,
Errors = IdResult.Errors.Select(e => e.Description).ToArray(),
};
return(BadRequest(result));
}
return(BadRequest(result));
}
