public void Update(Data.Entities.Role roleParam)
{
var role = _context.Roles.Find(roleParam.Id);
if (role is null)
{
throw new AppException("Role not found.");
}
if (String.IsNullOrWhiteSpace(roleParam.Name))
{
throw new AppException("Name can not be null.");
}
if (roleParam.Name != role.Name)
{
if (_context.Roles.Any(x => x.Name == roleParam.Name))
{
throw new AppException("Name " + roleParam.Name + " is already taken.");
}
}
role.Name = roleParam.Name;
_context.Roles.Update(role);
_context.SaveChanges();
}
public async Task <ActionResult <Data.Models.Role> > CreateNewRole(Data.Models.RoleForCreate newRole)
{
Data.Entities.Role dbNewRole = null;
try
{
dbNewRole = _mapper.Map <Data.Entities.Role>(newRole);
}
catch (Exception ex)
{
return(BadRequest("Input is in invalid format: " + ex.Message));
}
if (dbNewRole == null)
{
return(BadRequest("Input is in invalid format"));
}
await _repository.AddAsync <Data.Entities.Role>(dbNewRole);
await _repository.SaveChangesAsync();
Data.Models.Role addedRole = _mapper.Map <Data.Models.Role>(dbNewRole);
var url = _linkgenerator.GetPathByAction(HttpContext, "GetRoleByRoleId", "Roles", addedRole);
return(this.Created(url, addedRole));
}
public async Task <ActionResult <Data.Models.Role> > PatchRole(short roleId, JsonPatchDocument <Data.Models.RoleForUpdate> patchDocument)
{
try
{
Data.Entities.Role dbRole = await _repository.GetRoleAsync(roleId);
if (dbRole == null)
{
return(NotFound());
}
var updatedRole = _mapper.Map <Data.Models.RoleForUpdate>(dbRole);
patchDocument.ApplyTo(updatedRole, ModelState);
_mapper.Map(updatedRole, dbRole);
if (await _repository.SaveChangesAsync())
{
Data.Models.Role savedRole = _mapper.Map <Data.Models.Role>(await _repository.GetRoleAsync(roleId));
return(Ok(savedRole));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to save to database"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to patch role " + ex.Message));
}
}
public async Task <ActionResult <Data.Models.Role> > UpdateRole(short roleId, Data.Models.RoleForUpdate updatedRole)
{
try
{
Data.Entities.Role dbRole = await _repository.GetRoleAsync(roleId);
if (dbRole == null)
{
return(NotFound());
}
_mapper.Map(updatedRole, dbRole);
if (await _repository.SaveChangesAsync())
{
Data.Models.Role savedRole = _mapper.Map <Data.Models.Role>(dbRole);
return(Ok(savedRole));
}
else
{
return(BadRequest("Failed to update."));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public async Task <bool> Insert(RoleModel model)
{
var role = new Data.Entities.Role {
Id = model.Id, Name = model.Name
};
_context.Roles.Add(role);
await _context.SaveChangesAsync();
return(true);
}
public Data.Entities.Role Create(Data.Entities.Role role)
{
if (_context.Roles.Any(x => x.Name == role.Name))
{
throw new AppException("Role " + role.Name + " is already in use");
}
Guid roleId = new Guid();
role.Id = roleId;
_context.Roles.Add(role);
_context.SaveChanges();
return(role);
}
public async Task <UserRole> AssignRole(Guid userId, Guid roleId, Guid currentUser)
{
if (Guid.Empty == userId)
{
throw new AppException("UserId is required");
}
if (Guid.Empty == roleId)
{
throw new AppException("RoleId is required");
}
if (Guid.Empty == currentUser)
{
throw new AppException("Current user is required");
}
IAsyncEnumerator <Data.Entities.Role> _role = GetRolesByUserId(userId).GetAsyncEnumerator();
while (await _role.MoveNextAsync())
{
if (_role.Current.Id == roleId)
{
throw new AppException("User already assigned this role.");
}
}
Data.Entities.User user = _context.Users.Find(userId);
Data.Entities.Role role = _context.Roles.Find(roleId);
Guid newUserRoleId = Guid.NewGuid();
UserRole userRole = new UserRole
{
Id = newUserRoleId,
User = user,
Role = role,
CreatedBy = currentUser != Guid.Empty ? currentUser : userId,
CreatedDate = DateTime.Now,
DeletedBy = null,
DeletedDate = null,
};
_context.UserRoles.Add(userRole);
_context.SaveChanges();
return(userRole);
}
public async Task <IActionResult> DeleteRole(short roleId)
{
try
{
Data.Entities.Role dbRole = await _repository.GetRoleAsync(roleId);
if (dbRole == null)
{
return(NotFound());
}
_repository.Delete <Data.Entities.Role>(dbRole);
await _repository.SaveChangesAsync();
return(NoContent());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public IActionResult OnGet(int?id)
{
// define user ID
int currentUserID = userContext.UserEntity.UserID;
UserID = id ?? currentUserID;
Data.Entities.User userEntity;
// find user
if (UserID == currentUserID)
{
userEntity = userContext.UserEntity;
}
else if (!userContext.Rights.Full)
{
return(Forbid());
}
else
{
userEntity = webContext.ConfigDatabase.UserTable.GetItem(UserID);
}
// get user properties
if (userEntity == null)
{
Username = WebPhrases.UnknownUsername;
RoleName = "";
TimeZone = "";
}
else
{
Username = userEntity.Name;
Data.Entities.Role roleEntity = webContext.ConfigDatabase.RoleTable.GetItem(userEntity.RoleID);
RoleName = roleEntity == null ? "" : roleEntity.Name;
TimeZone = UserID == currentUserID ? userContext.TimeZone.DisplayName : CommonPhrases.UndefinedSign;
}
return(Page());
}
