public static int?GetRoleId(string roleName, DbAppContext context)
{
HetRole role = context.HetRole.AsNoTracking()
.FirstOrDefault(x => x.Name.ToLower().Contains(roleName.ToLower()));
return(role?.RoleId);
}
public virtual IActionResult RolesIdDeletePost([FromRoute] int id)
{
bool exists = _context.HetRole.Any(x => x.RoleId == id);
// not found
if (!exists)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// get record
HetRole role = _context.HetRole.First(x => x.RoleId == id);
// remove associated role permission records
List <HetRolePermission> itemsToRemove = _context.HetRolePermission
.Where(x => x.Role.RoleId == role.RoleId)
.ToList();
foreach (HetRolePermission item in itemsToRemove)
{
_context.HetRolePermission.Remove(item);
}
// remove role and save
_context.HetRole.Remove(role);
_context.SaveChanges();
return(new ObjectResult(new HetsResponse(role)));
}
public virtual IActionResult RolesIdPut([FromRoute] int id, [FromBody] HetRole item)
{
bool exists = _context.HetRole.Any(x => x.RoleId == id);
// not found
if (!exists)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// get record
HetRole role = _context.HetRole.First(x => x.RoleId == id);
role.ConcurrencyControlNumber = item.ConcurrencyControlNumber;
role.Name = item.Name;
role.Description = item.Description;
// save changes
_context.SaveChanges();
// get updated role
role = _context.HetRole.AsNoTracking()
.First(x => x.RoleId == id);
// return role permissions
return(new ObjectResult(new HetsResponse(role)));
}
public virtual IActionResult RolesIdPermissionsPost([FromRoute] int id, [FromBody] HetPermission item)
{
HetRole role = _context.HetRole.AsNoTracking()
.Where(x => x.RoleId == id)
.Include(x => x.HetRolePermission)
.ThenInclude(rolePerm => rolePerm.Permission)
.FirstOrDefault();
// not found
if (role == null)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
List <HetPermission> allPermissions = _context.HetPermission.ToList();
List <string> existingPermissionCodes = role.HetRolePermission.Select(x => x.Permission.Code).ToList();
if (!existingPermissionCodes.Contains(item.Code))
{
HetPermission permToAdd = allPermissions.FirstOrDefault(x => x.Code == item.Code);
// invalid permission
if (permToAdd == null)
{
throw new ArgumentException(string.Format("Invalid Permission Code {0}", item.Code));
}
// add permission
HetRolePermission rolePermission = new HetRolePermission
{
Permission = permToAdd,
Role = role
};
_context.HetRolePermission.Add(rolePermission);
}
_context.SaveChanges();
// get updated permissions
role = _context.HetRole.AsNoTracking()
.Where(x => x.RoleId == id)
.Include(x => x.HetRolePermission)
.ThenInclude(rp => rp.Permission)
.First();
// return role permissions
return(new ObjectResult(new HetsResponse(role.HetRolePermission.ToList())));
}
public virtual IActionResult RolesIdGet([FromRoute] int id)
{
bool exists = _context.HetRole.Any(x => x.RoleId == id);
// not found
if (!exists)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// get record
HetRole role = _context.HetRole.AsNoTracking().First(x => x.RoleId == id);
return(new ObjectResult(new HetsResponse(role)));
}
public virtual IActionResult RolesIdPermissionsGet([FromRoute] int id)
{
HetRole role = _context.HetRole.AsNoTracking()
.Where(x => x.RoleId == id)
.Include(x => x.HetRolePermission)
.ThenInclude(rp => rp.Permission)
.FirstOrDefault();
// not found
if (role == null)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// return role permissions
return(new ObjectResult(new HetsResponse(role.HetRolePermission.ToList())));
}
public virtual IActionResult RolesPost([FromBody] HetRole item)
{
HetRole role = new HetRole
{
Description = item.Description,
Name = item.Name
};
// save changes
_context.HetRole.Add(role);
_context.SaveChanges();
int id = role.RoleId;
// get updated role
role = _context.HetRole.AsNoTracking()
.First(x => x.RoleId == id);
// return role permissions
return(new ObjectResult(new HetsResponse(role)));
}
public virtual IActionResult RolesIdPermissionsPut([FromRoute] int id, [FromBody] HetPermission[] items)
{
HetRole role = _context.HetRole.AsNoTracking()
.Where(x => x.RoleId == id)
.Include(x => x.HetRolePermission)
.ThenInclude(rolePerm => rolePerm.Permission)
.FirstOrDefault();
// not found
if (role == null)
{
return(new ObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// get permissions
List <HetPermission> allPermissions = _context.HetPermission.AsNoTracking().ToList();
List <int> permissionIds = items.Select(x => x.PermissionId).ToList();
List <int> existingPermissionIds = role.HetRolePermission.Select(x => x.Permission.PermissionId).ToList();
List <int> permissionIdsToAdd = permissionIds.Where(x => !existingPermissionIds.Contains(x)).ToList();
// permissions to add
foreach (int permissionId in permissionIdsToAdd)
{
HetPermission permToAdd = allPermissions
.FirstOrDefault(x => x.PermissionId == permissionId);
// invalid permission
if (permToAdd == null)
{
throw new ArgumentException("Invalid Permission Code");
}
// add permission
HetRolePermission rolePermission = new HetRolePermission
{
PermissionId = permToAdd.PermissionId,
RoleId = role.RoleId
};
_context.HetRolePermission.Add(rolePermission);
}
// permissions to remove
List <HetRolePermission> permissionsToRemove = role.HetRolePermission
.Where(x => x.Permission != null &&
!permissionIds.Contains(x.Permission.PermissionId)).ToList();
foreach (HetRolePermission perm in permissionsToRemove)
{
_context.HetRolePermission.Remove(perm);
}
_context.SaveChanges();
// get updated permissions
role = _context.HetRole.AsNoTracking()
.Where(x => x.RoleId == id)
.Include(x => x.HetRolePermission)
.ThenInclude(rp => rp.Permission)
.First();
// return role permissions
return(new ObjectResult(new HetsResponse(role.HetRolePermission.ToList())));
}
/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="user"></param>
/// <param name="systemId"></param>
/// <param name="smUserId"></param>
/// <param name="firstName"></param>
/// <param name="lastName"></param>
/// <param name="maxUserIndex"></param>
private static void CopyToInstance(DbAppContext dbContext, ImportModels.UserHets oldObject,
ref HetUser user, string systemId, string smUserId, string firstName, string lastName,
ref int maxUserIndex)
{
try
{
// file contains multiple records per user (1 for each district they can access)
// we are currently importing 1 only -> where Default_Service_Area = Y
if (oldObject.Default_Service_Area != "Y")
{
return;
}
// check if this user already exists in the db
bool userExists = dbContext.HetUser.Any(x => x.SmUserId == smUserId);
if (userExists)
{
user = dbContext.HetUser.First(x => x.SmUserId == smUserId);
// *******************************************************************
// check if this is a different district
// *******************************************************************
int serviceAreaId;
try
{
serviceAreaId = int.Parse(oldObject.Service_Area_Id);
}
catch
{
// not mapped correctly
throw new ArgumentException(string.Format("User Error - Invalid Service Area (userId: {0}", user.SmUserId));
}
HetServiceArea serviceArea = dbContext.HetServiceArea.AsNoTracking()
.FirstOrDefault(x => x.MinistryServiceAreaId == serviceAreaId);
if (serviceArea == null)
{
// not mapped correctly
throw new ArgumentException(string.Format("User Error - Invalid Service Area (userId: {0}", user.SmUserId));
}
int tempUserId = user.UserId;
int?tempDistrictId = serviceArea.DistrictId;
if (tempDistrictId != null)
{
HetUserDistrict userDistrict = dbContext.HetUserDistrict.AsNoTracking()
.FirstOrDefault(x => x.User.UserId == tempUserId &&
x.District.DistrictId == tempDistrictId);
// ***********************************************
// create user district record
// ***********************************************
if (userDistrict == null)
{
userDistrict = new HetUserDistrict
{
UserId = tempUserId,
DistrictId = tempDistrictId,
AppCreateTimestamp = DateTime.UtcNow,
AppCreateUserid = systemId,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetUserDistrict.Add(userDistrict);
dbContext.SaveChangesForImport();
}
}
}
else
{
user = new HetUser
{
UserId = ++maxUserIndex,
Active = true,
SmUserId = smUserId,
SmAuthorizationDirectory = "IDIR"
};
if (!string.IsNullOrEmpty(firstName))
{
user.GivenName = firstName;
}
if (!string.IsNullOrEmpty(lastName))
{
user.Surname = lastName;
}
// *******************************************************************
// create initials
// *******************************************************************
string temp = "";
if (!string.IsNullOrEmpty(lastName) && lastName.Length > 0)
{
temp = lastName.Substring(0, 1).ToUpper();
}
if (!string.IsNullOrEmpty(firstName) && firstName.Length > 0)
{
temp = temp + firstName.Substring(0, 1).ToUpper();
}
if (!string.IsNullOrEmpty(temp))
{
user.Initials = temp;
}
// *******************************************************************
// map user to the correct service area
// *******************************************************************
int serviceAreaId;
try
{
serviceAreaId = int.Parse(oldObject.Service_Area_Id);
}
catch
{
// not mapped correctly
throw new ArgumentException(string.Format("User Error - Invalid Service Area (userId: {0}", user.SmUserId));
}
HetServiceArea serviceArea = dbContext.HetServiceArea.AsNoTracking()
.FirstOrDefault(x => x.MinistryServiceAreaId == serviceAreaId);
if (serviceArea == null)
{
// not mapped correctly
throw new ArgumentException(string.Format("User Error - Invalid Service Area (userId: {0}", user.SmUserId));
}
user.DistrictId = serviceArea.DistrictId;
// *******************************************************************
// set the user's role
// ** all new users will be added with basic access only
// *******************************************************************
HetUserRole userRole = new HetUserRole();
HetRole role = dbContext.HetRole.FirstOrDefault(x => x.Name == "HETS District User");
int roleId = -1;
if (role != null)
{
roleId = role.RoleId;
}
// ***********************************************
// create user
// ***********************************************
user.AppCreateTimestamp = DateTime.UtcNow;
user.AppCreateUserid = systemId;
user.AppLastUpdateUserid = systemId;
user.AppLastUpdateTimestamp = DateTime.UtcNow;
userRole.Role = dbContext.HetRole.First(x => x.RoleId == roleId);
userRole.EffectiveDate = DateTime.UtcNow.AddDays(-1);
userRole.AppCreateTimestamp = DateTime.UtcNow;
userRole.AppCreateUserid = systemId;
userRole.AppLastUpdateUserid = systemId;
userRole.AppLastUpdateTimestamp = DateTime.UtcNow;
user.HetUserRole = new List <HetUserRole> {
userRole
};
dbContext.HetUser.Add(user);
dbContext.SaveChangesForImport();
// ***********************************************
// create user district record
// ***********************************************
HetUserDistrict userDistrict = new HetUserDistrict
{
UserId = user.UserId,
DistrictId = user.DistrictId,
IsPrimary = true,
AppCreateTimestamp = DateTime.UtcNow,
AppCreateUserid = systemId,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetUserDistrict.Add(userDistrict);
dbContext.SaveChangesForImport();
}
}
catch (Exception ex)
{
Debug.WriteLine("***Error*** - Employee Id: " + oldObject.Popt_Id);
Debug.WriteLine("***Error*** - Master User Index: " + maxUserIndex);
Debug.WriteLine(ex.Message);
throw;
}
}
