public async Task <IActionResult> CreateRole(CreateRoleVM model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Admin"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
;
}
return(View(model));
}
//DONE
public async Task <ActionResult> PostRole(CreateRoleVM model)
{
try
{
if (ModelState.IsValid)
{
if (await _roleManager.RoleExistsAsync(model.Name))
{
return(BadRequest("Este rol ya ha sido creado anteriomente"));
}
var newRole = new IdentityRole {
Name = model.Name
};
var result = await _roleManager.CreateAsync(newRole);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Algo salio mal trantando de crear el rol. Intenta de nuevo o contacta al adminitrador del sistema"));
}
return(Json("El rol ha sido creado"));
}
return(BadRequest(FormatedModelStateErrors.GetErrorsFormated(ModelState)));
}
catch (Exception ex)
{
//TODO: Log the exception
return(StatusCode(StatusCodes.Status500InternalServerError,
"Algo salio mal trantando de crear el rol. Intenta de nuevo o contacta al adminitrador del sistema"));
}
}
public ActionResult Create(CreateRoleVM model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var rol = _mapper.Map <IdentityRole>(model);
rol.Id = Guid.NewGuid().ToString();
var result = _roleManager.CreateAsync(rol).Result;
if (!result.Succeeded)
{
ModelState.AddModelError("", "Something went wrong...");
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public IActionResult Create(CreateRoleVM role)
{
if (ModelState.IsValid)
{
_roles.Create(role.CreateRole());
return(RedirectToAction("PersonProjectIndex", "ProjectRole"));
}
return(View());
}
public IActionResult Create(CreateRoleVM roleVM)
{
if (ModelState.IsValid)
{
_roles.Create(roleVM.CreateRole());
return(RedirectToAction("Index"));
}
return(View(roleVM));
}
public IActionResult OnPostCreate(CreateRoleVM command)
{
if (!ModelState.IsValid)
{
return(RedirectToPage("Index"));
}
var result = _roleApplication.Create(command);
return(new JsonResult(result));
}
public IActionResult Create(CreateRoleVM rolevm)
{
if (ModelState.IsValid)
{
Role role = rolevm.CreateRole();
_roles.Create(role);
return(RedirectToAction("Index"));
}
return(View());
}
public OperationResult Create(CreateRoleVM command)
{
OperationResult result = new OperationResult();
if (_roleRepository.IsExist(r => r.Name == command.Name))
{
return(result.Failed(ValidateMessage.IsDuplicatedName));
}
var role = new Role(command.Name, command.Description);
_roleRepository.Create(role);
_roleRepository.SaveChanges();
_rolePermissionApplication.AddPermissionsToRole(role.Id, command.PermissionsId);
return(result.Succeeded());
}
public ActionResult CreateRole(CreateRoleVM vm)
{
if (ModelState.IsValid)
{
db = new ApplicationDbContext();
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
if (!roleManager.RoleExists(vm.Roles))
{
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = vm.Roles;
roleManager.Create(role);
return(Json(new { success = true }));
}
else
{
ModelState.AddModelError("Role Already exist", "Role Already exist");
return(PartialView("_RoleCreate", vm));
}
}
return(PartialView("_RoleCreate", vm));
}
public async Task <IHttpActionResult> Create(CreateRoleVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = new IdentityRole {
Name = model.Name
};
var result = await this.AppRoleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
Uri locationHeader = new Uri(Url.Link("GetRoleById", new { id = role.Id }));
return(Created(locationHeader, (role)));
}
public async Task <IActionResult> CreateRole([FromBody] CreateRoleVM model)
{
ValidationResult validationResult = _roleValidator.Validate(model);
List <string> errors = new List <string>();
if (!validationResult.IsValid)
{
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
return(BadRequest(errors));
}
Log.Information("[CUSTOM] Creating role with name '{RoleName}' at {Now}", model.RoleName, DateTime.UtcNow);
IdentityRole role = new IdentityRole
{
Name = model.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
Log.Information("[CUSTOM] Role with name '{RoleName}' successfully created.", model.RoleName);
return(Ok());
}
foreach (var error in result.Errors)
{
errors.Add(error.Description);
}
return(BadRequest(errors));
}
public async Task <IActionResult> Create(CreateRoleVM RoleObj)
{
if (ModelState.IsValid)
{
IdentityRole CreatedRole = new IdentityRole
{
Name = RoleObj.RoleName
};
var result = await roleManager.CreateAsync(CreatedRole);
if (result.Succeeded)
{
return(RedirectToAction("RolesList"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(RoleObj));
}
public async Task <ResponseResult> CreateRole(CreateRoleVM role) => await rolesClient.CreateAsync(role);
public async Task <ActionResult <ResponseResult> > Create([FromBody] CreateRoleVM model)
{
var response = await business.Create(model.Name);
return(Ok(response));
}
public IActionResult CreateRole()
{
CreateRoleVM model = new CreateRoleVM();
return(View(model));
}
