public ActionResult DeleteRole(AppRoleViewModel model)
{
//get role
model.DeleteRole(model.ID);
return(RedirectToAction("RoleManager", "admin"));
//return Json(new { succeed = true }, JsonRequestBehavior.AllowGet);
}
public ActionResult DeleteRole(string id)
{
var model = new AppRoleViewModel();
model.GetValueByID(id);
return(PartialView(model));
}
public async Task <IActionResult> SaveItem(AppRoleViewModel appRoleViewModel)
{
if (ModelState.IsValid)
{
var errors = new Dictionary <string, string>();
if (appRoleViewModel.IsEdit == false)
{
await _roleService.CreateAsync(appRoleViewModel);
}
else
{
await _roleService.UpdateAsync(appRoleViewModel);
}
return(Json(new JsonResponse()
{
Success = true,
Message = Constants.SaveDataSuccess
}));
}
return(Json(new JsonResponse
{
Success = false,
Message = Constants.SaveDataFailed,
Errors = ModelState.Where(modelState => modelState.Value.Errors.Count > 0).ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).FirstOrDefault()
)
}));
}
public AppRole Add(AppRoleViewModel model)
{
var appRole = _mapper.Map <AppRoleViewModel, AppRole>(model);
_appDbContext.AppRoles.Add(appRole);
return(appRole);
}
public async Task <IActionResult> Update([FromBody] AppRoleViewModel appRoleVm)
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "ROLE", Operations.Update);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
if (ModelState.IsValid)
{
try
{
AppRole appRole = await _roleManager.FindByIdAsync(appRoleVm.Id.ToString());
appRole.UpdateAppRole(appRoleVm);
await _roleManager.UpdateAsync(appRole);
return(new OkObjectResult(appRoleVm));
}
catch (Exception ex)
{
return(new BadRequestObjectResult(ex.Message));
}
}
return(new BadRequestObjectResult(ModelState));
}
public ActionResult NewRole(AppRole data)
{
var model = new AppRoleViewModel();
model.SetValue(data);
return(Json(new { succeed = true }, JsonRequestBehavior.AllowGet));
}
public async Task <BaseReponse <ModelListResult <AppRoleViewModel> > > GetAllPagingAsync(AppRoleRequest request)
{
var query = (await _roleManager.Roles.ToListAsync()).ToList();
if (!string.IsNullOrEmpty(request.SearchText))
{
query = query.Where(x => x.Name.Contains(request.SearchText) ||
x.Description.Contains(request.SearchText)).ToList();
}
int totalRow = query.Count;
query = (query.Skip(request.PageIndex * request.PageSize)
.Take(request.PageSize)).ToList();
var items = new AppRoleViewModel().Map(query).ToList();
var result = new BaseReponse <ModelListResult <AppRoleViewModel> >
{
Data = new ModelListResult <AppRoleViewModel>()
{
Items = items,
Message = Message.Success,
RowCount = totalRow,
PageSize = request.PageSize,
PageIndex = request.PageIndex
},
Message = Message.Success,
Status = (int)QueryStatus.Success
};
return(result);
}
private void save_Roles()
{
_appRoleViewModel = new AppRoleViewModel
{
Name = txtNhomQuyen.Text.Trim(), Description = txtMoTa.Text.Trim()
};
}
protected override async Task OnInitializedAsync()
{
Interceptor.RegisterEvent();
_noTextToDisplay = _localizer[LangKey.NO_DATA_TO_DISPLAY];
var apiCultureResult = await _apiWrapper.Cultures.GetAllAsync();
if (apiCultureResult.IsSuccess && apiCultureResult.Error == null)
{
_lstCultures = apiCultureResult.Data
.Where(cul => cul.DisplayName != LangConfig.CULT_TRANSLATION)
.ToList();
}
var apiRoleResult = await _apiWrapper.Roles.GetAllAsync();
if (apiRoleResult.IsSuccess && apiRoleResult.Error == null)
{
_lstRoles = apiRoleResult.Data;
}
var apiUserResult = await _apiWrapper.Users.GetAllAsync(_search);
if (apiUserResult.IsSuccess && apiUserResult.Error == null)
{
_userViewModel = apiUserResult.Data;
}
_currentUserRole = await _authService.GetCurrentUserRoleAsync();
//_rolesForCreate = GetRolesForCreate();
//_rolesForUpdate = GetRolesForUpdate();
}
public async Task <IActionResult> SaveEntity(AppRoleViewModel roleVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (!roleVm.Id.HasValue)
{
var result = await _roleService.AddAsync(roleVm);
if (result == false)
{
return(new OkObjectResult(new GenericResult(false, roleVm)));
}
}
else
{
var result = await _roleService.UpdateAsync(roleVm);
if (result == false)
{
return(new OkObjectResult(new GenericResult(false, roleVm)));
}
}
return(new OkObjectResult(new GenericResult(true, roleVm)));
}
public async Task <IActionResult> AddEditAppRole(string id, AppRoleViewModel model)
{
if (model == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
bool isExist = !string.IsNullOrEmpty(id);
AppRole applicationRole = isExist ? await _roleManager.FindByIdAsync(id).ConfigureAwait(false) :
new AppRole
{
CreatedDate = DateTime.UtcNow
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
applicationRole.IPAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
IdentityResult roleRuslt = isExist ? await _roleManager.UpdateAsync(applicationRole).ConfigureAwait(false)
: await _roleManager.CreateAsync(applicationRole).ConfigureAwait(false);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task UpdateAsync(AppRoleViewModel roleVm)
{
var role = await _roleManager.FindByIdAsync(roleVm.Id);
role.Description = roleVm.Description;
role.Name = roleVm.Name;
await _roleManager.UpdateAsync(role);
}
public async Task <IActionResult> SaveEntity(AppRoleViewModel roleVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (!roleVm.Id.HasValue)
{
var notificationId = Guid.NewGuid().ToString();
//var announcement = new AnnouncementViewModel()
//{
// Title = "Role created",
// DateCreated = DateTime.Now,
// Content = $"Role {roleVm.Name} has been created",
// Id = notificationId,
// UserId = User.GetUserId()
//};
//var announcementUsers = new List<AnnouncementUserViewModel>()
//{
// new AnnouncementUserViewModel(){AnnouncementId = notificationId,HasRead = false,UserId = User.GetUserId()}
//};
//await _roleService.AddAsync(announcement, announcementUsers, roleVm);
//await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
else
{
await _roleService.UpdateAsync(roleVm);
}
return(new OkObjectResult(roleVm));
}
public frmNhomQuyen(IRoleService roleService, IFunctionService functionService)
{
InitializeComponent();
_roleService = roleService;
_functionService = functionService;
_appRoleViewModel = new AppRoleViewModel();
_permissionViewModel = new PermissionViewModel();
}
/// <summary>
/// Update role
/// </summary>
/// <param name="appRoleViewModel">Role</param>
/// <returns></returns>
public async Task UpdateAsync(AppRoleViewModel appRoleViewModel)
{
var role = await _roleManager.FindByIdAsync(appRoleViewModel.Id.ToString());
role.Description = appRoleViewModel.Description;
role.Name = appRoleViewModel.Name;
await _roleManager.UpdateAsync(role);
}
public async Task <IActionResult> SaveEntity(AppRoleViewModel roleViewModel)
{
if (!ModelState.IsValid)
{
var allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (!roleViewModel.Id.HasValue)
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Role {roleViewModel.Name} has been created",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
await _roleService.AddAsync(announcement, announcementUsers, roleViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
else
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Role {roleViewModel.Name} has been updated",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
await _roleService.UpdateAsync(announcement, announcementUsers, roleViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
return(new OkObjectResult(roleViewModel));
}
public async Task UpdateAsync(AppRoleViewModel roleVm)
{
var role = await _roleManager.FindByIdAsync(roleVm.Id.ToString());
role.Description = roleVm.Description;
role.Name = roleVm.Name;
role.DateModified = DateTime.Now;
await _roleManager.UpdateAsync(role);
}
public async Task <bool> UpdateAsync(AppRoleViewModel roleViewModel)
{
var role = await _roleManager.FindByIdAsync(roleViewModel.Id.ToString());
role.Description = roleViewModel.Description;
role.Name = roleViewModel.Name;
var result = await _roleManager.UpdateAsync(role);
return(result.Succeeded);
}
public async Task<bool> AddAsync(AppRoleViewModel roleVm)
{
var role = new AppRole()
{
Name = roleVm.Name,
Description = roleVm.Description
};
var result = await _roleManager.CreateAsync(role);
return result.Succeeded;
}
public async Task UpdateAsync(AppRoleViewModel appRoleViewModel)
{
var roles = await _roleManager.FindByIdAsync(appRoleViewModel.Id.ToString());
roles.Name = appRoleViewModel.Name;
roles.Description = appRoleViewModel.Description;
await _roleManager.UpdateAsync(roles);
await _unitOfWork.CommitAsync();
}
public async Task UpdateAsync(AppRoleViewModel roleViewModel)
{
var role = await _roleManager.FindByIdAsync(roleViewModel.Id.ToString());
role.Description = roleViewModel.Description;
role.Name = roleViewModel.Name;
await _roleManager.UpdateAsync(role);
_unitOfWork.Commit();
}
public async Task <IActionResult> Update([FromBody] AppRoleViewModel appRoleViewModel)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
await _roleService.UpdateAsync(appRoleViewModel);
return(new NoContentResult());
}
public async Task UpdateAsync(AppRoleViewModel roleVm)
{
var role = await _roleManager.FindByIdAsync(roleVm.Id.ToString());
role.Description = roleVm.Description;
role.Name = roleVm.Name;
role.Type = roleVm.Type;
role.ModuleId = roleVm.ModuleId;
role.SortOrder = roleVm.SortOrder;
await _roleManager.UpdateAsync(role);
}
public async Task <AppRoleViewModel> ExecuteAsync(Guid id)
{
var role = await _roleManager.FindByIdAsync(id.ToString());
AppRoleViewModel roleViewModel = new AppRoleViewModel();
roleViewModel.Id = role.Id;
roleViewModel.Name = role.Name;
roleViewModel.Description = role.Description;
return(roleViewModel);
}
public async Task <IActionResult> Create([FromBody] AppRoleViewModel appRoleViewModel)
{
if (appRoleViewModel == null || !ModelState.IsValid)
{
return(new BadRequestResult());
}
await _roleService.AddAsync(appRoleViewModel);
return(new OkResult());
}
public async Task <bool> AddAsync(AppRoleViewModel appRoleViewModel)
{
var role = new AppRole
{
Name = appRoleViewModel.Name,
Description = appRoleViewModel.Description
};
var result = await _roleManager.CreateAsync(role);
return(result.Succeeded);
}
public async Task <IActionResult> Create([FromBody] AppRoleViewModel appRoleViewModel)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(string.Join("\r\n", allErrors.Select(x => x.ErrorMessage))));
}
await _roleService.AddAsync(appRoleViewModel);
return(new NoContentResult());
}
public async Task <bool> AddAsync(AppRoleViewModel roleViewModel)
{
var role = new AppRole()
{
Name = roleViewModel.Name,
Description = roleViewModel.Description
};
var result = await _roleManager.CreateAsync(role);
_unitOfWork.Commit();
return(result.Succeeded);
}
public static void UpdateApplicationRole(this AppRole appRole, AppRoleViewModel appRoleViewModel, string action = "add")
{
if (action == "update")
{
appRole.Id = appRoleViewModel.Id;
}
else
{
appRole.Name = appRoleViewModel.Name;
}
appRole.Description = appRoleViewModel.Description;
}
public async Task <bool> AddAsync(AppRoleViewModel roleViewModel)
{
var role = new AppRole()
{
Name = roleViewModel.Name,
Description = roleViewModel.Description,
CreatedDate = DateTime.Now
};
var result = await this._roleManager.CreateAsync(role);
return(result.Succeeded);
}
