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(); }