public async Task <IActionResult> AddRole(RoleAddViewModel roleAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(roleAddViewModel));
}
var role = new IdentityRole
{
Name = roleAddViewModel.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(roleAddViewModel));
}
public ActionResult Add(RoleAddViewModel viewModel)
{
if (ModelState.IsValid)
{
Role role = new Role
{
EntityInfo = EntityInfo.Empty(Dom.EntityType.Role.Id),
Name = viewModel.Name,
Description = viewModel.Description
};
EntityContext.AddEntityProgress(role.EntityInfo, new EntityProgress
{
OrganizationId = Dom.Common.OrganizationId,
EntityStateAfterId = Dom.EntityType.Role.State.Created
});
EntityContext.AddEntityProgress(role.EntityInfo, new EntityProgress
{
OrganizationId = Dom.Common.OrganizationId,
EntityStateBeforeId = Dom.EntityType.Role.State.Created,
EntityStateAfterId = Dom.EntityType.Role.State.Active
});
EntityContext.AddEntityOrganization(role.EntityInfo, Dom.Common.OrganizationId, Dom.EntityType.Role.State.Active);
_roleRepository.AddOrUpdate(role);
_roleRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(Mvc.Controller.Role.List, Mvc.Controller.Role.Name));
}
return(View(Mvc.View.Role.Add, viewModel));
}
public ActionResult AddRole(RoleAddViewModel model)
{
try
{
using (TransactionScope scope = new TransactionScope())
{
var roleId = RoleService.AddRole(model.Name);
PerissionService.AddPermissions(roleId, model.Permissions);
scope.Complete();
}
return(Json(new AjaxResult <RoleDTO>
{
code = 0,
count = 0,
data = null,
msg = "添加成功"
}));
}
catch (Exception ex)
{
Log.Error(ex.Message);
return(Json(new AjaxResult <RoleDTO>
{
code = 1,
count = 0,
data = null,
msg = ex.Message
}));
}
}
public async Task <IActionResult> AddRole([FromBody] RoleAddViewModel roleAddViewModel)
{
var role = new ApplicationIdentityRole
{
Id = roleAddViewModel.RoleID,
Name = roleAddViewModel.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(Json("SUCCEED"));
}
return(Json("角色添加失败!"));
}
public IActionResult Add(RoleAddViewModel model)
{
if (ModelState.IsValid)
{
var role = new Role();
role.Name = model.Name;
_roleService.Add(role);
TempData["Message"] = "Rol başarıyla eklendi";
TempData["MessageState"] = "warning";
return(RedirectToAction("Roles", "Admin"));
}
TempData["Message"] = "Bir hata oluştu!";
TempData["MessageState"] = "danger";
return(RedirectToAction("Roles", "Admin"));
}
public async Task <IActionResult> AddRole(RoleAddViewModel roleAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(roleAddViewModel));
}
var role = new ApplicationUserRole
{
Name = roleAddViewModel.RoleName
};
var resule = await _roleManager.CreateAsync(role);
if (resule.Succeeded)
{
return(RedirectToAction("Index"));
}
return(View(roleAddViewModel));
}
public ActionResult RoleAdd()
{
RoleAddViewModel model = new RoleAddViewModel();
List <Permissions> MenuList = new List <Permissions>();
foreach (var parent in permissionService.GetByParentId(0))
{
Permissions parentList = new Permissions();
parentList.Parent = parent;
if (permissionService.GetByParentId((long)parent.TypeID) == null)
{
continue;
}
parentList.Child = permissionService.GetByParentId((long)parent.TypeID);
MenuList.Add(parentList);
}
model.PermissionList = MenuList;
return(View(model));
}
public async Task <IActionResult> Add(RoleAddViewModel viewModel)
{
if (ModelState.IsValid)
{
var record = _mapper.Map <ApplicationRole>(viewModel);
var result = await _roleManager.CreateAsync(record).ConfigureAwait(false);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.ToString());
}
}
return(View(viewModel));
}
public async Task <IActionResult> Create(RoleAddViewModel roleAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(roleAddViewModel));
}
var role = new CustomIdentityRole
{
Name = roleAddViewModel.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Rol eklenemedi.");
return(View(roleAddViewModel));
}
return(RedirectToAction("Index", "Role"));
}
public IActionResult Remove()
{
List <RoleDTO> roles = this.roleManager.Roles
.Select(x => new RoleDTO {
RoleName = x.Name, RoleId = x.Id
})
.ToList();
List <UserDTO> users = this.userManager.Users
.Select(x => new UserDTO {
Username = x.UserName, Id = x.Id
})
.ToList();
RoleAddViewModel viewModel = new RoleAddViewModel()
{
Roles = roles,
Users = users
};
return(View(viewModel));
}
public async Task <IActionResult> AddRole(RoleAddViewModel roleAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(roleAddViewModel));
}
var role = _mapper.Map <IdentityRole>(roleAddViewModel);
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError(string.Empty, item.Description);
}
return(View(roleAddViewModel));
}
}
public async Task <ActionResult> Add(RoleAddViewModel data)
{
if (ModelState.IsValid)
{
try
{
data.active = true;
data.createdBy = Session["user_id"].ToString();
data.createdDatetime = DateTime.Now;
var postTask = await client.PostAsJsonAsync("/api/Roles/Add", data);
if (postTask.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Roles"));
}
}
catch (Exception e)
{
ViewBag.Error = e.Message;
return(View("Index", ViewBag.Error));
}
}
return(RedirectToActionPermanent("Index"));
}
public ActionResult Add()
{
RoleAddViewModel model = new RoleAddViewModel();
return(View("Add", model));
}
public IActionResult Add()
{
var model = new RoleAddViewModel();
return(View(model));
}
public async Task <JsonResult> checkRoleIfExist(RoleAddViewModel data)
{
return(await checkRole(data.comp_id, data.role_id)
? Json(true, JsonRequestBehavior.AllowGet)
: Json(false, JsonRequestBehavior.AllowGet));
}
