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