public async Task <Tuple <bool, string[]> > UpdateRoleAsync(ApplicationRole role, IEnumerable <string> claims)
{
if (claims != null)
{
var invalidClaims = claims.Where(c => ApplicationPermissions.GetPermissionByValue(c) == null).ToArray();
if (invalidClaims.Any())
{
return(Tuple.Create(false, new string[] { "The following claim types are invalid: " + string.Join(", ", invalidClaims) }));
}
}
var result = await _roleManager.UpdateAsync(role);
if (!result.Succeeded)
{
return(Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray()));
}
if (claims != null)
{
var roleClaims = (await _roleManager.GetClaimsAsync(role)).Where(c => c.Type == CustomClaimTypes.Permission);
var roleClaimValues = roleClaims.Select(c => c.Value).ToArray();
var claimsToRemove = roleClaimValues.Except(claims).ToArray();
var claimsToAdd = claims.Except(roleClaimValues).Distinct().ToArray();
if (claimsToRemove.Any())
{
foreach (string claim in claimsToRemove)
{
result = await _roleManager.RemoveClaimAsync(role, roleClaims.FirstOrDefault(c => c.Value == claim));
if (!result.Succeeded)
{
return(Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray()));
}
}
}
if (claimsToAdd.Any())
{
foreach (string claim in claimsToAdd)
{
result = await _roleManager.AddClaimAsync(role, new Claim(CustomClaimTypes.Permission, ApplicationPermissions.GetPermissionByValue(claim)));
if (!result.Succeeded)
{
return(Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray()));
}
}
}
}
return(Tuple.Create(true, new string[] { }));
}
public async Task SeedAsync()
{
await _context.Database.MigrateAsync().ConfigureAwait(false);
if (!await _context.Users.AnyAsync())
{
const string adminRoleName = "administrator";
const string userRoleName = "user";
await ensureRoleAsync(adminRoleName, "Default administrator", ApplicationPermissions.GetAllPermissionValues());
await ensureRoleAsync(userRoleName, "Default user", new string[] { });
await createUserAsync("admin", "admini123", "Inbuilt Administrator", "admin", "+1 (123) 000-0000", new string[] { adminRoleName });
await createUserAsync("user", "user123", "Inbuilt Standard User", "user", "+1 (123) 000-0001", new string[] { userRoleName });
}
if (!await _context.Customers.AnyAsync() && !await _context.ProductCategories.AnyAsync())
{
Customer cust_1 = new Customer
{
Name = "Ebenezer Monney",
Email = "*****@*****.**",
Gender = Gender.Male,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Customer cust_2 = new Customer
{
Name = "Itachi Uchiha",
Email = "*****@*****.**",
PhoneNumber = "+81123456789",
Address = "Some fictional Address, Street 123, Konoha",
City = "Konoha",
Gender = Gender.Male,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Customer cust_3 = new Customer
{
Name = "John Doe",
Email = "*****@*****.**",
PhoneNumber = "+18585858",
Address = @"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio.
Praesent libero. Sed cursus ante dapibus diam. Sed nisi. Nulla quis sem at nibh elementum imperdiet",
City = "Lorem Ipsum",
Gender = Gender.Male,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Customer cust_4 = new Customer
{
Name = "Jane Doe",
Email = "*****@*****.**",
PhoneNumber = "+18585858",
Address = @"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio.
Praesent libero. Sed cursus ante dapibus diam. Sed nisi. Nulla quis sem at nibh elementum imperdiet",
City = "Lorem Ipsum",
Gender = Gender.Male,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
ProductCategory prodCat_1 = new ProductCategory
{
Name = "None",
Description = "Default category. Products that have not been assigned a category",
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Product prod_1 = new Product
{
Name = "BMW M6",
Description = "Yet another masterpiece from the world's best car manufacturer",
BuyingPrice = 109775,
SellingPrice = 114234,
UnitsInStock = 12,
IsActive = true,
ProductCategory = prodCat_1,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Product prod_2 = new Product
{
Name = "Nissan Patrol",
Description = "A true man's choice",
BuyingPrice = 78990,
SellingPrice = 86990,
UnitsInStock = 4,
IsActive = true,
ProductCategory = prodCat_1,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
Order ordr_1 = new Order
{
Discount = 500,
Cashier = await _context.Users.FirstAsync(),
Customer = cust_1,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow,
OrderDetails = new List <OrderDetail>()
{
new OrderDetail()
{
UnitPrice = prod_1.SellingPrice, Quantity = 1, Product = prod_1
},
new OrderDetail()
{
UnitPrice = prod_2.SellingPrice, Quantity = 1, Product = prod_2
},
}
};
Order ordr_2 = new Order
{
Cashier = await _context.Users.FirstAsync(),
Customer = cust_2,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow,
OrderDetails = new List <OrderDetail>()
{
new OrderDetail()
{
UnitPrice = prod_2.SellingPrice, Quantity = 1, Product = prod_2
},
}
};
_context.Customers.Add(cust_1);
_context.Customers.Add(cust_2);
_context.Customers.Add(cust_3);
_context.Customers.Add(cust_4);
_context.Products.Add(prod_1);
_context.Products.Add(prod_2);
_context.Orders.Add(ordr_1);
_context.Orders.Add(ordr_2);
await _context.SaveChangesAsync();
}
}
public async Task <Tuple <bool, string[]> > CreateRoleAsync(ApplicationRole role, IEnumerable <string> claims)
{
if (claims == null)
{
claims = new string[] { }
}
;
var invalidClaims = claims.Where(c => ApplicationPermissions.GetPermissionByValue(c) == null).ToArray();
if (invalidClaims.Any())
{
return(Tuple.Create(false, new string[] { "The following claim types are invalid: " + string.Join(", ", invalidClaims) }));
}
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray()));
}
role = await _roleManager.FindByNameAsync(role.Name);
foreach (string claim in claims.Distinct())
{
result = await this._roleManager.AddClaimAsync(role, new Claim(CustomClaimTypes.Permission, ApplicationPermissions.GetPermissionByValue(claim)));
if (!result.Succeeded)
{
await DeleteRoleAsync(role);
return(Tuple.Create(false, result.Errors.Select(e => e.Description).ToArray()));
}
}
return(Tuple.Create(true, new string[] { }));
}
public async Task <ApiResponse> CreateRoleAsync([FromBody] RoleDto newRole)
{
try
{
// first make sure the role doesn't already exist
if (_roleManager.Roles.Any(r => r.Name == newRole.Name))
{
return(new ApiResponse(400, "Role already exists"));
}
// Create the role
var result = await _roleManager.CreateAsync(new IdentityRole <Guid>(newRole.Name));
if (!result.Succeeded)
{
string errorMessage = result.Errors.Select(x => x.Description).Aggregate((i, j) => i + " - " + j);
return(new ApiResponse(500, errorMessage));
}
// Re-create the permissions
IdentityRole <Guid> role = await _roleManager.FindByNameAsync(newRole.Name);
foreach (string claim in newRole.Permissions)
{
var resultAddClaim = await _roleManager.AddClaimAsync(role, new Claim(ClaimConstants.Permission, ApplicationPermissions.GetPermissionByName(claim)));
if (!resultAddClaim.Succeeded)
{
await _roleManager.DeleteAsync(role);
}
}
}
catch (Exception ex)
{
return(new ApiResponse(500, ex.Message));
}
return(new ApiResponse(200));
}
public async Task <ApiResponse> UpdateRoleAsync([FromBody] RoleDto newRole)
{
try
{
// first make sure the role already exist
if (!_roleManager.Roles.Any(r => r.Name == newRole.Name))
{
return(new ApiResponse(400, "This role doesn't exists"));
}
// Create the permissions
IdentityRole <Guid> identityRole = await _roleManager.FindByNameAsync(newRole.Name);
var claims = await _roleManager.GetClaimsAsync(identityRole);
var permissions = claims.Where(x => x.Type == ClaimConstants.Permission).Select(x => x.Value).ToList();
foreach (var permission in permissions)
{
await _roleManager.RemoveClaimAsync(identityRole, new Claim(ClaimConstants.Permission, permission));
}
foreach (string claim in newRole.Permissions)
{
var result = await _roleManager.AddClaimAsync(identityRole, new Claim(ClaimConstants.Permission, ApplicationPermissions.GetPermissionByName(claim)));
if (!result.Succeeded)
{
await _roleManager.DeleteAsync(identityRole);
}
}
}
catch (Exception ex)
{
return(new ApiResponse(500, ex.Message));
}
return(new ApiResponse(200));
}
public async Task <ApiResponse> GetRoleAsync(string roleName)
{
RoleDto roleDto;
IdentityRole <Guid> identityRole;
// get paginated list of users
try
{
identityRole = await _roleManager.FindByNameAsync(roleName);
}
catch (Exception ex)
{
throw new Exception(null, ex);
}
try
{
var claims = await _roleManager.GetClaimsAsync(identityRole);
var permissions = claims.Where(x => x.Type == "permission").Select(x => ApplicationPermissions.GetPermissionByValue(x.Value).Name).ToList();
roleDto = new RoleDto
{
Name = roleName,
Permissions = permissions
};
}
catch (Exception ex)
{
throw new Exception(null, ex);
}
return(new ApiResponse(200, "Role fetched", roleDto));
}
public async Task <ApiResponse> GetRoles([FromQuery] int pageSize = 10, [FromQuery] int pageNumber = 0)
{
var roleDtoList = new List <RoleDto>();
List <IdentityRole <Guid> > listResponse;
// get paginated list of roles
try
{
var roleList = _roleManager.Roles.AsQueryable();
listResponse = roleList.OrderBy(x => x.Id).Skip(pageNumber * pageSize).Take(pageSize).ToList();
}
catch (Exception ex)
{
throw new Exception(null, ex);
}
try
{
foreach (var role in listResponse)
{
var claims = await _roleManager.GetClaimsAsync(role);
var permissions = claims.Where(x => x.Type == "permission").Select(x => ApplicationPermissions.GetPermissionByValue(x.Value).Name).ToList();
roleDtoList.Add(new RoleDto
{
Name = role.Name,
Permissions = permissions
});;
}
}
catch (Exception ex)
{
throw new Exception(null, ex);
}
return(new ApiResponse(200, "Roles list fetched", roleDtoList));
}
public ApiResponse GetPermissions()
{
var permissions = ApplicationPermissions.GetAllPermissionNames();
return(new ApiResponse(200, "Permissions list fetched", permissions));
}
public async Task SeedAsync()
{
await _context.Database.MigrateAsync().ConfigureAwait(false);
var result = await _context.Users.AnyAsync();
if (!await _context.Users.AnyAsync())
{
_logger.LogInformation("Generating inbuilt accounts");
const string adminRoleName = "administrator";
const string userRoleName = "user";
await EnsureRoleAsync(adminRoleName, "Default administrator", ApplicationPermissions.GetAllPermissionValues());
await EnsureRoleAsync(userRoleName, "Default user", new string[] { });
await CreateUserAsync("admin", "tempP@ss123", "Administrator", "*****@*****.**", "+1 (123) 000-0000", new string[] { adminRoleName });
await CreateUserAsync("Nyasha", "tempP@ss123", "Standard User", "*****@*****.**", "+1 (123) 000-0001", new string[] { userRoleName });
await CreateUserAsync("Grace", "tempP@ss123", "Administrator", "*****@*****.**", "+1 (123) 000-0001", new string[] { adminRoleName });
await CreateUserAsync("Martin", "tempP@ss123", "Standard User", "*****@*****.**", "+1 (123) 000-0001", new string[] { userRoleName });
await CreateUserAsync("User1", "tempP@ss123", "Standard User", "*****@*****.**", "+1 (123) 000-0001", new string[] { userRoleName });
await CreateUserAsync("User2", "tempP@ss123", "Standard User", "*****@*****.**", "+1 (123) 000-0001", new string[] { userRoleName });
await CreateUserAsync("User3", "tempP@ss123", "Standard User", "*****@*****.**", "+1 (123) 000-0001", new string[] { userRoleName });
_logger.LogInformation("Inbuilt account generation has completed");
}
if (!await _context.ProjectSources.AnyAsync())
{
_logger.LogInformation("Seeding initial data");
var source1 = new ProjectSource {
Name = "Facebook"
};
var source2 = new ProjectSource {
Name = "Google"
};
var source3 = new ProjectSource {
Name = "Reference"
};
var source4 = new ProjectSource {
Name = "Website"
};
_context.ProjectSources.AddRange(source4, source3, source2, source1);
_logger.LogInformation("Seeding initial data completed");
}
if (!await _context.ProjectStatuses.AnyAsync())
{
_logger.LogInformation("Seeding initial data");
var pS1 = new ProjectStatus {
Name = "Parked"
};
var pS2 = new ProjectStatus {
Name = "In Progress"
};
var pS3 = new ProjectStatus {
Name = "Awaiting Approval"
};
var pS4 = new ProjectStatus {
Name = "Completed"
};
_context.ProjectStatuses.AddRange(pS4, pS3, pS2, pS1);
await _context.SaveChangesAsync();
_logger.LogInformation("Seeding initial data completed");
}
}
virtual public async Task SeedAsync()
{
await _context.Database.MigrateAsync().ConfigureAwait(false);
//if (!await _context.Users.AnyAsync())
//{
try
{
_logger.LogInformation("Generating inbuilt accounts");
const string superAdminRoleName = "Super Administrators";
//const string userRoleName = "user";
await EnsureRoleAsync(superAdminRoleName, "Default super administrators", ApplicationPermissions.GetAllPermissionValues());
//await EnsureRoleAsync(userRoleName, "Default user", new string[] { });
//await CreateUserAsync("admin", "P@55w0rdtest", "Inbuilt Administrator", "*****@*****.**", "0911205712", new string[] { adminRoleName });
//await CreateUserAsync("user", "P@55w0rdtest", "Inbuilt Standard User", "*****@*****.**", "0911205712", new string[] { userRoleName });
await CreateUserAsync("SuperAdmin", "P@55w0rdtest", "Inbuilt Super Administrator", "*****@*****.**", "0911205712", new string[] { superAdminRoleName });
_logger.LogInformation("Inbuilt account generation completed");
}
catch (Exception ex)
{
string s = ex.Message;
throw new Exception(ex.Message);
}
//}
}
