public bool UpdateRole(CreateRoleModel model)
{
try
{
var sql = "CMS_ROLE_UpdateWithFunc";
var sqlParams = new[]
{
new SqlParameter("p_role_id", SqlDbType.Int),
new SqlParameter("p_role_name", SqlDbType.NVarChar),
new SqlParameter("p_role_desc", SqlDbType.NVarChar),
new SqlParameter("p_array_func_id", SqlDbType.VarChar)
};
sqlParams[0].Value = model.RoleId;
sqlParams[1].Value = model.RoleName;
sqlParams[2].Value = model.RoleDesc;
sqlParams[3].Value = GetListFuncsFromString(model.ArrayFunc);
var dt = db.ExecuteDataTable(CommandType.StoredProcedure, sql, sqlParams);
return true;
}
catch (Exception ex)
{
NLogHelper.Logger.Error(string.Format("UpdateRole: {0}", ex.ToString()));
return false;
}
}
public async Task <IActionResult> CreateRole(CreateRoleModel model)
{
if (ModelState.IsValid)
{
//Role Name
IdentityRole identityRole = new IdentityRole()
{
Name = model.RoleName
};
//Saves Role Name in the 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 async Task <ActionResult> Create(CreateRoleModel model)
{
if (ModelState.IsValid)
{
var result = await RoleManager.CreateAsync(new ApplicationRole
{
Name = model.Name,
Description = model.Description
});
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
await RoleManager.DeleteAsync(RoleManager.FindByName(model.Name));
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
public JsonResult CreateRole(CreateRoleModel model)
{
var check = _roleStoreService.CreateRole(model);
var msg = check ? "Add new role successfully" : string.Format("The role name {0} is existed.", model.RoleName);
return(Json(msg));
}
public async Task <MessageReponse> CreateRole(CreateRoleModel model)
{
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role != null)
{
return(new MessageReponse()
{
Message = "Role already exists ",
IsSuccess = false,
});
}
role = new AppRole()
{
Name = model.RoleName.ToUpper(),
Description = model.Description
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(new MessageReponse()
{
Message = "Create Successed ",
IsSuccess = true,
});
}
return(new MessageReponse()
{
Message = "Create Failed ",
IsSuccess = false,
});
}
public async Task <IActionResult> CreateRole(string groupid, string roleid)
{
Group group = await _context.Groups.FindAsync(groupid);
User user = await _userManager.GetUserAsync(User);
if (string.IsNullOrWhiteSpace(roleid))
{
roleid = "";
}
GroupRole role = await _context.GroupRoles.FindAsync(roleid);
CreateRoleModel model;
if (role == null)
{
model = new CreateRoleModel()
{
GroupId = group.Id
};
}
else
{
model = CreateRoleModel.FromExisting(role);
}
return(View(model));
}
public HttpResponseMessage CreateRole(CreateRoleModel model)
{
var responseMsg = this.ExceptionHandler(
() =>
{
var context = new AutoMorgueContext();
var roles = context.Roles;
var role = roles.FirstOrDefault(r => r.Name == model.Name);
if (role == null)
{
role = new Role
{
Name = model.Name
};
}
else
{
throw new Exception();
}
context.Roles.Add(role);
context.SaveChanges();
var response = this.Request.CreateResponse(HttpStatusCode.Created, role);
return(response);
});
return(responseMsg);
}
public async Task <ActionResult> CreateRole(CreateRoleModel model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await _accountService.CreateRoleAsync(identityRole);
if (result.Succeeded)
{
return(StatusCode(200)); // 200: Ok
}
else
{
var errors = result.Errors;
return(BadRequest(errors)); // 400: BadRequest
}
}
else
{
var errors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
errors.Add(error.ErrorMessage);
}
}
return(BadRequest(errors)); // 400: BadRequest
}
}
public ActionResult CreateRole(CreateRoleModel model)
{
if (ModelState.IsValid)
{
try
{
var role = db.Roles.Where(u => String.Compare(u.RoleName, model.RoleName, true) == 0).FirstOrDefault();
if (role == null)
{
role = new Role();
role.RoleName = model.RoleName;
role.Description = model.Description;
db.Roles.Add(role);
db.SaveChanges();
return(RedirectToAction("ListRoles"));
}
else
{
ModelState.AddModelError("", "Chức danh tên <strong>" + model.RoleName + "</strong> đã tồn tại trong hệ thống. Vui lòng nhập chức danh khác!");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "Error: " + ex.ToString());
EventWriter.WriteEventLog("SystemController - CreateRole: " + ex.ToString());
}
}
return(View(model));
}
public async Task <IActionResult> Post([FromBody] CreateRoleModel model)
{
var roleExists = await roleManager.FindByNameAsync(model.Name);
if (roleExists != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "Role already exists!"
}));
}
IdentityRole role = new IdentityRole()
{
Name = model.Name,
NormalizedName = string.IsNullOrEmpty(model.NormalizedName)
? model.Name.Replace(" ", "").ToUpper()
: model.NormalizedName
};
var result = await roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response {
Status = "Error", Message = "Role creation failed! Please check role details and try again."
}));
}
return(Ok(role));
}
public ActionResult Create(CreateRoleModel model)
{
try
{
if (ModelState.IsValid)
{
IdentityResult result = RoleManager.Create(new ApplicationRole
{
Name = model.Name,
Description = model.Description
});
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Что-то пошло не так");
}
}
return(View(model));
}
catch (Exception e)
{
return(RedirectToAction("Index", "Error", new { error = e.Message }));
}
}
public CreateRoleModel GetRoleById(string id)
{
try
{
var roleStore = new RoleStore();
var model = new CreateRoleModel();
var dt = roleStore.GetRoleById(id);
if (dt.Rows.Count == 0)
{
return(null);
}
model.RoleId = Int64.Parse(dt.Rows[0]["ROLE_ID"].ToString());
model.RoleName = dt.Rows[0]["ROLE_NAME"].ToString();
model.RoleDesc = dt.Rows[0]["ROLE_DESC"].ToString();
model.UserId = Int64.Parse(dt.Rows[0]["USER_ID"].ToString());
model.RoleStatus = dt.Rows[0]["ROLE_STATUS"].ToString() == "1";
model.ArrayFunc = GetListFuncId(dt);
return(model);
}
catch (Exception ex)
{
return(null);
}
}
public Task <Result <Guid> > Add(CreateRoleModel model)
=> Result <Guid> .TryAsync(async() =>
{
var featureIds = model.Feature;
var resultList = await _repository.ListAsync <Feature>(f => featureIds.Contains(f.Id));
if (!resultList.Success || resultList.Data == null)
{
return(Result <Guid> .Failed(Error.WithCode(ErrorCodes.InvalidModel)));
}
var features = resultList.Data;
if (features.Count != featureIds.Count())
{
return(Result <Guid> .Failed(Error.WithCode(ErrorCodes.InvalidModel)));
}
var roleId = Guid.NewGuid();
var role = new Role
{
Id = roleId, Name = model.Name, RoleFeature = features.Select(f => new RoleFeature
{
RoleId = roleId, FeatureId = f.Id, Id = Guid.NewGuid()
}).ToList()
};
_repository.Add(role);
await _repository.CommitAsync();
return(Result <Guid> .Successful(roleId));
});
public async Task <ActionResult> _Create(CreateRoleModel model)
{
var nameResponse = await WepApiMethod.SendApiAsync <bool>(HttpVerbs.Get, $"Administration/Role/IsRoleNameExist?id={null}&name={model.Name}");
if (nameResponse.isSuccess)
{
TempData["ErrorMessage"] = "Role Name already registered in the system";
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
var response = await WepApiMethod.SendApiAsync <int>(HttpVerbs.Post, $"Administration/Role", model);
if (response.isSuccess)
{
TempData["SuccessMessage"] = "Role successfully added";
await LogActivity(Modules.Setting, "Create Role", model);
return(RedirectToAction("List"));
}
}
TempData["ErrorMessage"] = "Fail to add new role";
return(RedirectToAction("List"));
}
public async Task <IActionResult> CreateRole(CreateRoleModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (ModelState.IsValid)
{
var role = new MawRole
{
Name = model.Name,
Description = model.Description
};
model.Result = await _roleMgr.CreateAsync(role);
}
else
{
model.Result = IdentityResult.Failed();
LogValidationErrors();
}
return(View(model));
}
public JsonResult EditRole(CreateRoleModel model)
{
var check = _roleStoreService.UpdateRole(model);
var msg = check ? "Update Role Success." : "Update Role Error";
return(Json(msg));
}
public async Task <IActionResult> CreateRole(CreateRoleViewModel model)
{
if (ModelState.IsValid)
{
// CreateRoleViewModel --> CreateRoleModel
var roleModel = new CreateRoleModel {
Role = model.RoleName
};
//CreateRoleModel--> IdentityRole
var role = new IdentityRole {
Name = roleModel.Role
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administration"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public ActionResult CreateMemberRoles()
{
var members = db.tb_MemberMaster;
List <object> memberList = new List <object>();
foreach (var member in members)
{
memberList.Add(new
{
Id = member.MemberID,
Name = member.FirstName + " " + member.LastName
});
}
CreateRoleModel model = new CreateRoleModel()
{
_MemberID = 0,
_Members = new SelectList(memberList, "Id", "Name"),
_RoleID = 0,
_Roles = new SelectList(db.tb_Roles, "RoleID", "RoleName"),
_BodyID = 0,
_Bodies = new SelectList(db.tb_Body, "BodyID", "BodyName"),
_StartDate = DateTime.Now,
_EndDate = DateTime.Now
};
return(View(model));
}
public async Task <UserManagerResponse> CreateRoleAsync(CreateRoleModel model)
{
var identityRole = new IdentityRole()
{
Name = model.Name,
NormalizedName = model.NormalizedName
};
var result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(new UserManagerResponse
{
Message = "Role created successfully!",
IsSuccess = true,
});
}
return(new UserManagerResponse
{
Message = "Role did not create",
IsSuccess = false,
Errors = result.Errors.Select(e => e.Description)
});
}
public async Task <IActionResult> CreateRole(CreateRoleModel 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
};
//await _roleLogic.CreateRole();
// Saves the role in the underlying AspNetRoles table
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("index", "Role"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IHttpActionResult> Create(CreateRoleModel model)
{
var currentRole = await AppRoleManager.FindByNameAsync(model.Name);
if (currentRole != null)
{
ModelState.AddModelError("Name", "A role with this name already exists");
}
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, TheModelFactory.CreateViewModel(role)));
}
public async Task <IActionResult> CreateRole(CreateRoleModel 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> CreateRole(CreateRoleModel createRoleModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("CreateRole"));
}
var role = new Role()
{
Name = createRoleModel.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(RedirectToAction("CreateRole"));
}
//SUCCEDEED
TempData["RoleStatus"] = "RoleCreated";
return(RedirectToAction("Roles"));
}
//create the new role
private string CreateRole(CreateRoleModel model)
{
if (ModelState.IsValid)
{
IdentityResult result = RoleManager.Create(new ApplicationRole {
Name = model.Name,
Description = model.Description
});
if (result.Succeeded)
{
return("User role created successfully");
}
else
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
//unite all errors in one string
return(string.Join(",",
ModelState.Values.Where(E => E.Errors.Count > 0)
.SelectMany(E => E.Errors)
.Select(E => E.ErrorMessage)
.ToArray()));
}
public ActionResult Edit(string id)
{
IdentityRole role = context.Roles.Where(r => r.Id == id).FirstOrDefault();
CreateRoleModel rolemodel = AutoMapper.Mapper.Map <CreateRoleModel>(role);
return(View(rolemodel));
}
public async Task <IdentityResult> CreateRoleAsync(CreateRoleModel model)
{
var role = Mapper.Map <Role>(model);
var result = await roleManager.CreateAsync(role);
return(result);
}
public async Task <IdentityResult> Create(CreateRoleModel model)
{
IdentityResult result = await _roleManager.CreateAsync(new ApplicationRole
{
Name = model.Name,
});
return(result);
}
public IHttpActionResult Put(long id, [FromBody] CreateRoleModel model)
{
using (var t = Repository.BeginTransaction())
{
var role = RoleService.UpdateRole(id, model.Name, model.Description);
t.Commit();
return(Json(role));
}
}
/// <summary>
/// создание GET
/// </summary>
/// <returns></returns>
public ActionResult Create()
{
var model = new CreateRoleModel
{
IsActive = true
};
return(View(model));
}
public async Task <IdentityResult> CreateRoleAsync(CreateRoleModel model)
{
var entity = model.ToDest();
PrepareCreate(entity);
var result = await _roleManager.CreateAsync(entity);
return(result);
}
public async Task<IHttpActionResult> AddRole(CreateRoleModel role)
{
CustomRole r = new CustomRole(role.NewRole);
IdentityResult result = await RoleManager.CreateAsync(r);
if (!result.Succeeded)
{
return GetErrorResult(result);
}
return Ok();
}
public async Task Roles_Create_Delete_Add_Remove_Unauthorized()
{
CreateRoleModel modelCreate = new CreateRoleModel()
{
NewRole = "Admin"
};
string str = String.Format("NewRole={0}", Uri.EscapeUriString(modelCreate.NewRole));
StringContent theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
HttpResponseMessage response = await _client.PostAsync("api/Account/AddRole", theContent);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
DeleteRoleModel modelDelete = new DeleteRoleModel()
{
DeleteRole = "TestRole"
};
str = String.Format("DeleteRole={0}", Uri.EscapeUriString(modelDelete.DeleteRole));
theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
response = await _client.PostAsync("api/Account/DeleteRole", theContent);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
UserToRoleModel model = new UserToRoleModel()
{
Role = "Test",
User = "******"
};
str = String.Format("Role={0}&User={1}", Uri.EscapeUriString(model.Role), Uri.EscapeUriString(model.User));
theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
response = await _client.PostAsync("api/Account/AddUserToRole", theContent);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
str = String.Format("Role={0}&User={1}", Uri.EscapeUriString(model.Role), Uri.EscapeUriString(model.User));
theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
response = await _client.PostAsync("api/Account/RemoveUserRole", theContent);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
response = await _client.GetAsync("api/Account/GetUserRoles" + String.Format("?email={0}", Uri.EscapeUriString(model.User)));
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
}
public async Task Roles_Create_Existing_Role()
{
CreateRoleModel model = new CreateRoleModel()
{
NewRole = "Admin"
};
LoginTokenModel token = await getAdminToken();
_client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", token.access_token));
string str = String.Format("NewRole={0}", Uri.EscapeUriString(model.NewRole));
StringContent theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
HttpResponseMessage response = await _client.PostAsync("api/Account/AddRole", theContent);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
string responseBody = await response.Content.ReadAsStringAsync();
ErrorValidationModel tweb = ServiceStack.Text.JsonSerializer.DeserializeFromString<ErrorValidationModel>(responseBody);
Assert.AreEqual(tweb.ModelState.FirstOrDefault().Value, "[Name Admin is already taken.]");
clearToken();
}
public async Task Roles_Create_Delete_Role()
{
DeleteRoleModel modelDelete = new DeleteRoleModel()
{
DeleteRole = "TestRole"
};
CreateRoleModel model = new CreateRoleModel()
{
NewRole = "TestRole"
};
LoginTokenModel token = await getAdminToken();
_client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", token.access_token));
string str = String.Format("NewRole={0}", Uri.EscapeUriString(model.NewRole));
StringContent theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
HttpResponseMessage response = await _client.PostAsync("api/Account/AddRole", theContent);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
str = String.Format("DeleteRole={0}", Uri.EscapeUriString(modelDelete.DeleteRole));
theContent = new StringContent(str, System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
response = await _client.PostAsync("api/Account/DeleteRole", theContent);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
clearToken();
}
