public async Task <IActionResult> Create(ApplicationRoleDTO applicationRoleDTO) { if (ModelState.IsValid) { var role = new IdentityRole { Id = Guid.NewGuid().ToString(), Name = applicationRoleDTO.Name }; EntityEntry <IdentityRole> ApplicationRole = _context.Roles.Add(role); try { _context.SaveChanges(); } catch (Exception e) { ModelState.AddModelError(string.Empty, _localizer["Entity insert error, Retry."]); return(View(applicationRoleDTO)); } //if (ApplicationRole == null) //{ //} return(RedirectToAction(nameof(Index))); } return(View(applicationRoleDTO)); }
/// <inheritdoc /> public async Task <ApplicationRoleDTO> UpdateAsync(ApplicationRoleDTO applicationRoleDto) { if (applicationRoleDto == null) { throw new ArgumentNullException(nameof(applicationRoleDto)); } return(await this.Repository.TransactionalExecutionAsync( action : async(role, transaction) => { //Search the entity var roleDb = await this.Repository.GetByIdAsync(role.Id); if (roleDb == null) { throw new EntityNotFoundException <ApplicationRole>(role.Id); } //Copy the values roleDb.CopyFrom(this.Mapper.Map <ApplicationRole>(role)); roleDb.NormalizedName = roleDb.Name.Normalize(); //Save await this.Repository.SaveChangesAsync(); }, obj : this.Mapper.Map <ApplicationRole>(applicationRoleDto), onSuccessFunc : role => this.Mapper.Map <ApplicationRoleDTO>(role))); }
public async Task <object> DeleteAsync(string Id) { var model = await this.roleManager.FindByIdAsync(Id); IdentityResult result = await this.roleManager.DeleteAsync(model); if (result.Succeeded) { this.DisplayMessage = CommonMethods.GetMessage(LogType.Role, LogAction.Delete); ApplicationRoleDTO modelDTO = Mapper.Map <ApplicationRole, ApplicationRoleDTO>(model); return(modelDTO); } else { this.IsSuccess = false; List <ErrorMessageDTO> errors = new List <ErrorMessageDTO>(); foreach (var item in result.Errors) { errors.Add(new ErrorMessageDTO() { Message = item.Description, Code = item.Code }); } this.ErrorMessages = errors; return(null); } }
/// <inheritdoc /> public async Task DeleteAsync(Guid roleId, ApplicationRoleDTO newRoleForUsers) { //On vérifie que le nouveau rôle n'est pas nul et qu'il existe if (newRoleForUsers == null) { throw new ArgumentNullException(nameof(newRoleForUsers)); } var newRole = await this.Repository.GetByIdAsync(newRoleForUsers.Id); if (newRole == null) { throw new EntityNotFoundException <ApplicationRole>(newRoleForUsers.Id); } //Récupération du rôle à supprimer var roleToDelete = await this.Repository.GetByIdAsync(roleId); if (roleToDelete == null) { throw new EntityNotFoundException <ApplicationRole>(roleId); } await this.Repository.TransactionalExecutionAsync( action : async(role, transaction) => { //Copy the values role.CopyFrom(this.Mapper.Map <ApplicationRole>(role)); role.NormalizedName = role.Name.Normalize(); //Save await this.Repository.SaveChangesAsync(); }, obj : this.Mapper.Map <ApplicationRole>(roleToDelete)); }
/// <inheritdoc /> public async Task <ApplicationRoleDTO> CreateAsync(ApplicationRoleDTO roleDto) { if (roleDto == null) { throw new ArgumentNullException(nameof(roleDto)); } var role = this.Mapper.Map <ApplicationRole>(roleDto); // Check if the element is unique var existingProfile = await this.Repository.GetByUniqueKeyAsync(role); if (existingProfile != null) { throw new EntityAlreadyExistsException <ApplicationRole>(existingProfile); } //Create the element return(await this.Repository.TransactionalExecutionAsync( action : async(roleToCreate, transaction) => { // Save it roleToCreate.NormalizedName = roleToCreate.Name.Normalize(); await this.Repository.AddAsync(roleToCreate); await this.Repository.SaveChangesAsync(); }, obj : role, onSuccessFunc : createdRole => this.Mapper.Map <ApplicationRoleDTO>(createdRole))); }
public async Task <IActionResult> DeleteAsync([FromRoute] Guid roleId, [FromBody] ApplicationRoleDTO newRoleForUsers) { await this.Service.DeleteAsync(roleId, newRoleForUsers); return(this.NoContent()); }
public async Task <object> GetByIdAsync(string Id) { var model = await this.roleManager.FindByIdAsync(Id); ApplicationRoleDTO modelDTO = Mapper.Map <ApplicationRole, ApplicationRoleDTO>(model); return(modelDTO); }
//public IEnumerable<ApplicationRoleDTO> Find(Func<ApplicationRoleDTO, Boolean> predicate) //{ // //var conv = new ExpressionConverter(); // //Expression<Func<ApplicationRoleDTO, bool>> bllExpr = mc => predicate(mc); // //Expression <Func<ApplicationRole, bool>> dllExpr = (Expression<Func<ApplicationRole, bool>>)conv.Convert(bllExpr); // Func<ApplicationRole, bool> userPredicate = u => predicate(MapSourceToDest(u)); // // применяем автомаппер для проекции одной коллекции на другую // var mapper = new MapperConfiguration(cfg => cfg.CreateMap<ApplicationRole, ApplicationRoleDTO>()).CreateMapper(); // return mapper.Map<IEnumerable<ApplicationRole>, List<ApplicationRoleDTO>>(Database.RoleManager..ApplicationRoles.Find(userPredicate)); //} ApplicationRoleDTO MapSourceToDest(ApplicationRole v) { ApplicationRoleDTO dest = new ApplicationRoleDTO(); var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ApplicationRoleDTO, ApplicationRole>()).CreateMapper(); dest = mapper.Map <ApplicationRole, ApplicationRoleDTO>(v); return(dest); }
async public Task UpdateAsync(ApplicationRoleDTO entity) { var mappedRole = _mapper.Map <ApplicationRole>(entity); await _roleUnitOfWork.RoleRepository.UpdateAsync(mappedRole); await _roleUnitOfWork.SaveAsync(); }
protected override async Task OnParametersSetAsync() { if (!string.IsNullOrEmpty(roleId)) { Title = "Edit"; role = await Http.GetJsonAsync <ApplicationRoleDTO>("/api/Role/" + roleId); } }
public async Task <object> SaveUpdateAsync(ApplicationRoleDTO modelDTO) { IdentityResult result; ApplicationRole model; if (string.IsNullOrEmpty(modelDTO.Id)) { model = new ApplicationRole() { Name = modelDTO.Name, Priority = modelDTO.Priority, CreatedDate = Converters.GetCurrentEpochTime(), UpdatedDate = Converters.GetCurrentEpochTime(), IsActive = true, IsDeleted = false }; result = await this.roleManager.CreateAsync(model); modelDTO = Mapper.Map <ApplicationRole, ApplicationRoleDTO>(model); this.DisplayMessage = CommonMethods.GetMessage(LogType.Role, LogAction.Add); } else { model = await this.roleManager.FindByIdAsync(modelDTO.Id); model.Name = modelDTO.Name; model.Priority = modelDTO.Priority; model.UpdatedDate = Converters.GetCurrentEpochTime(); model.IsActive = modelDTO.IsActive; model.IsDeleted = modelDTO.IsDeleted; result = await this.roleManager.UpdateAsync(model); modelDTO = Mapper.Map <ApplicationRole, ApplicationRoleDTO>(model); this.DisplayMessage = CommonMethods.GetMessage(LogType.Role, LogAction.Update); } if (result.Succeeded) { modelDTO.Id = model.Id; return(modelDTO); } else { this.IsSuccess = false; this.DisplayMessage = ""; List <ErrorMessageDTO> errors = new List <ErrorMessageDTO>(); foreach (var item in result.Errors) { errors.Add(new ErrorMessageDTO() { Message = item.Description, Code = item.Code }); } this.ErrorMessages = errors; return(null); } }
async public Task InsertAsync(ApplicationRoleDTO entity) { entity.Id = Guid.NewGuid().ToString(); var mappedRole = _mapper.Map <ApplicationRole>(entity); await _roleUnitOfWork.RoleRepository.InsertAsync(mappedRole); await _roleUnitOfWork.SaveAsync(); }
public async Task <IActionResult> GetApplicationUser(string username) { var manager = ServiceLocator.Current.GetInstance <IMiniSessionService>(); var repo = new Repository(manager); ApplicationUser applicationUser; try { applicationUser = repo.GetById <ApplicationUser>(username); } catch { return(new NotFoundResult()); } var userDto = new ApplicationUserDTO { accessFailedCount = applicationUser.AccessFailedCount, email = applicationUser.Email, lockoutEnabled = applicationUser.LockoutEnabled, lockoutEndDate = applicationUser.LockoutEndDate, name = applicationUser.Name, phoneNumber = applicationUser.PhoneNumber, username = applicationUser.UserName }; foreach (var role in applicationUser.Roles) { var roleDTO = new ApplicationRoleDTO { Description = role.Description, Id = role.Id, IsCustom = role.IsCustom, Name = role.Name }; foreach (var permission in role.Permissions) { var permissionDTO = new ApplicationPermissionDTO { Description = permission.Description, Id = permission.Id, IsCustom = permission.IsCustom, Name = permission.Name }; roleDTO.Permissions.Add(permissionDTO); } userDto.roles.Add(roleDTO); } return(Ok(new { value = userDto } )); }
public async Task <IActionResult> Edit(string id, ApplicationRoleDTO applicationRoleDTO) { //if (id != applicationUser.Id) //{ // return NotFound(); //} IdentityRole Role = null; if (ModelState.IsValid) { try { //ApplicationUserDTO ApplicationUserDTO = null; Role = _context.Roles.First(x => x.Id == id); //ApplicationUserDTO = _mapper.Map<ApplicationUserDTO>(ApplicationUser); if (Role == null) { return(NotFound()); } Role.Name = applicationRoleDTO.Name; _context.Update(Role); return(View(applicationRoleDTO)); } catch (DbUpdateConcurrencyException) { if (!ApplicationRoleExists(Role.Id)) { return(NotFound()); } else { ModelState.AddModelError(string.Empty, _localizer["Entity edit error, Retry."]); return(View(applicationRoleDTO)); } } return(RedirectToAction(nameof(Index))); } return(View(applicationRoleDTO)); }
// GET: ApplicationUsers/Edit/5 public async Task <IActionResult> Edit(string id) { if (string.IsNullOrEmpty(id)) { return(NotFound()); } var applicationRole = await _context.Roles.FindAsync(id); if (applicationRole == null) { return(NotFound()); } ApplicationRoleDTO ApplicationRoleDTO = null; ApplicationRoleDTO = _mapper.Map <ApplicationRoleDTO>(applicationRole); return(View(ApplicationRoleDTO)); }
public ActionResult <ApplicationRoleDTO> PostRole(ApplicationRoleDTO applicationRoleDTO) { var manager = ServiceLocator.Current.GetInstance <IMiniSessionService>(); var repo = new Repository(manager); var applicationRole = new ApplicationRole { Description = applicationRoleDTO.Description, Name = applicationRoleDTO.Name, IsCustom = applicationRoleDTO.IsCustom }; foreach (var permissionDTO in applicationRoleDTO.Permissions) { var applicationPermission = repo.GetById <ApplicationPermission>(permissionDTO.Id); applicationRole.AddPermissions(applicationPermission); } repo.Save <ApplicationRole>(applicationRole); manager.Session.Flush(); return(CreatedAtAction("PostRole", new { id = applicationRole.Id }, applicationRole)); }
public async Task <IActionResult> GetApplicationRole(int?id) { var manager = ServiceLocator.Current.GetInstance <IMiniSessionService>(); var repo = new Repository(manager); ApplicationRole applicationRole; try { applicationRole = repo.GetById <ApplicationRole>(id); } catch { return(new NotFoundResult()); } var applicationRoleDTO = new ApplicationRoleDTO { Description = applicationRole.Description, Id = applicationRole.Id, IsCustom = applicationRole.IsCustom, Name = applicationRole.Name }; foreach (var permisison in applicationRole.Permissions) { var pemrissionDTO = new ApplicationPermissionDTO { Description = permisison.Description, Id = permisison.Id, IsCustom = permisison.IsCustom, Name = permisison.Name }; applicationRoleDTO.Permissions.Add(pemrissionDTO); } return(Ok(new { value = applicationRoleDTO } )); }
public async Task <IActionResult> GetApplicationRoles() { var manager = ServiceLocator.Current.GetInstance <IMiniSessionService>(); var repo = new Repository(manager); var roles = repo.GetAll <ApplicationRole>(); var results = new List <ApplicationRoleDTO>(); foreach (var role in roles) { var roleDTO = new ApplicationRoleDTO { Description = role.Description, Id = role.Id, IsCustom = role.IsCustom, Name = role.Name }; foreach (var permission in role.Permissions) { var permissionDTO = new ApplicationPermissionDTO { Description = permission.Description, Id = permission.Id, IsCustom = permission.IsCustom, Name = permission.Name }; roleDTO.Permissions.Add(permissionDTO); } results.Add(roleDTO); } return(Ok(new { value = results } )); }
public ActionResult PutApplicationRole(ApplicationRoleDTO applicationRoleDTO, int?id) { var manager = ServiceLocator.Current.GetInstance <IMiniSessionService>(); var repo = new Repository(manager); var applicationRole = repo.GetById <ApplicationRole>(id); if (applicationRole == null) { return(new NotFoundResult()); } applicationRole.Description = applicationRoleDTO.Description; applicationRole.Name = applicationRoleDTO.Name; applicationRole.IsCustom = applicationRoleDTO.IsCustom; applicationRole.ClearPermissions(); foreach (var permissionDTO in applicationRoleDTO.Permissions) { var applicationPermission = repo.GetById <ApplicationPermission>(permissionDTO.Id); applicationRole.AddPermissions(applicationPermission); } repo.Save <ApplicationRole>(applicationRole); manager.Session.Flush(); return(NoContent()); }
public async Task <object> Post([FromBody] ApplicationRoleDTO model) { try { var data = await _repository.SaveUpdateAsync(model); _response.Result = data; _response.IsSuccess = _repository.IsSuccess; _response.ErrorMessages = _repository.ErrorMessages; _response.DisplayMessage = _repository.DisplayMessage; } catch (Exception ex) { _response.IsSuccess = false; _response.ErrorMessages = new List <ErrorMessageDTO>() { new ErrorMessageDTO() { Message = ex.ToString() } }; } return(_response); }
protected void DeleteRoleConfirm(ApplicationRoleDTO role) { this.selectedRole = roles.FirstOrDefault(item => item.Id == role.Id); this.ShowConfirmation = true; }
async protected Task DeleteRole(ApplicationRoleDTO role) { await Http.DeleteAsync($"api/Role/{role.Id}"); await GetRoles(); }
public async Task <IActionResult> UpdateAsync([FromBody] ApplicationRoleDTO roleDto) { await Service.UpdateAsync(roleDto); return(this.NoContent()); }
async protected Task EditRole(ApplicationRoleDTO role) { await Http.SendJsonAsync(HttpMethod.Put, "/api/Role", role); }
public async Task <IActionResult> CreateAsync([FromBody] ApplicationRoleDTO roleDto) { ApplicationRoleDTO result = await this.Service.CreateAsync(roleDto); return(Created($"{HttpContext.Request.Path}/{result.Id}", result)); }
async public Task Put([FromBody] ApplicationRoleDTO role) { await _asyncRoleManager.UpdateAsync(role); }
async public Task Post([FromBody] ApplicationRoleDTO role) { await _asyncRoleManager.InsertAsync(role); }