public async Task <Result <bool> > CreateClaimsPrincipal(ClaimsPrincipal claimsPrincipal)
{
var scopes = claimsPrincipal.Scopes;
var claims = claimsPrincipal.Claims;
scopes.ForEach(async x => await _userScopeRepository.CreateScope(new DALUserScopeModel
{
Type = x.Type,
UserAccountId = claimsPrincipal.UserAccountId
}));
claims.ForEach(async x => await _userClaimRepository.CreateUserClaim(new DALUserClaimModel()
{
Type = x.Type,
Value = x.Value,
UserAccountId = claimsPrincipal.UserAccountId
}));
var allDalScopes = await _scopeRepository.GetAllScopes();
var allDalClaims = await _claimRepository.GetAllClaims();
var dalScopes = new List <ScopeModel>();
foreach (var dalScope in allDalScopes)
{
foreach (var scope in scopes)
{
if (dalScope.Type.ToUpper() == scope.Type.ToUpper())
{
dalScopes.Add(dalScope);
}
}
}
var dalClaims = new List <ClaimModel>();
foreach (var dalClaim in allDalClaims)
{
foreach (var claim in claims)
{
if (dalClaim.Type.ToUpper() == claim.Type.ToUpper())
{
dalClaims.Add(dalClaim);
}
}
}
var dalUserScopes = await _userScopeRepository.GetAllUserScopesByUserAccountId(claimsPrincipal.UserAccountId);
var dalUserClaims = await _userClaimRepository.GetAllUserClaimsByUserAccountId(claimsPrincipal.UserAccountId);
var allBlScopes = await _scopeService.GetAllScopes();
var allBlClaims = await _claimService.GetAllClaims();
var blScopes = new List <BusinessModels.UserAccessControl.ScopeModel>();
foreach (var blScope in allBlScopes)
{
foreach (var dalScope in dalUserScopes)
{
if (blScope.Type.ToUpper() == dalScope.Type.ToUpper())
{
blScopes.Add(blScope);
}
}
}
var blClaims = new List <BusinessModels.UserAccessControl.ClaimModel>();
foreach (var blClaim in allBlClaims)
{
foreach (var dalClaim in dalClaims)
{
if (blClaim.Type.ToUpper() == dalClaim.Type.ToUpper())
{
blClaims.Add(blClaim);
}
}
}
foreach (var dalUserScope in dalUserScopes)
{
var requiredClaims = blScopes.Where(x => x.Type == dalUserScope.Type).FirstOrDefault().Claims;
var requiredDALClaims = dalUserClaims.Where(x => x.Type == (requiredClaims.Where(y => y.Type == x.Type).FirstOrDefault().Type)).ToList();
foreach (var dalUserClaim in dalUserClaims)
{
foreach (var requiredClaim in requiredClaims)
{
if (requiredClaim.Type.ToUpper() == dalUserClaim.Type.ToUpper())
{
requiredDALClaims.Add(dalUserClaim);
}
}
}
requiredDALClaims.ForEach(async x => await _userScopeClaimRepository.CreateUserScopeClaim(new UserScopeClaimModel
{
UserAccountId = claimsPrincipal.UserAccountId,
UserScopeId = dalUserScope.Id,
UserClaimId = x.Id,
Role = claimsPrincipal.Role
}));
}
return(Result <bool> .Success(true));
}
public async Task <Result <AssignmentPolicyModel> > GetAssignmentPolicyByRole(string role, int priority)
{
// Get all assignment policies
var assignmentPolices = (await _assignmentPolicyRepository.GetAllAssignmentPolicies()).ToList();
//Get all assignment policies for the user's role
var roledAssignmentPolicies = new List <Models.User_Access_Control.AssignmentPolicyModel>();
foreach (var policy in assignmentPolices)
{
if (policy.RequiredAccountType.ToUpper() == role.ToUpper())
{
roledAssignmentPolicies.Add(policy);
}
}
// for each assignment policy for that user's role
// // if the priority of that policy is equal to the desired priority or is equal to 1
// // // grab that policy
var assignmentPolicy = new Models.User_Access_Control.AssignmentPolicyModel();
foreach (var roledAssignmentPolicy in roledAssignmentPolicies)
{
if (roledAssignmentPolicy.Priority == priority || roledAssignmentPolicy.Priority == 1)
{
assignmentPolicy = roledAssignmentPolicy;
break;
}
}
// Get all junction tables between assignment policies and scopes
var assignmentPairingPolicies = (await _assignmentPolicyPairingRepository.GetAllAssignmentPolicyPairings()).ToList();
// for policy-scope junction table
// // if the junction table's policy id is equal to the desired policy
// // // grab that junction table
var assignmentPairingPolicy = new AssignmentPolicyPairingModel();
var blScopes = (await _scopeService.GetAllScopes()).ToList();
foreach (var policyPairing in assignmentPairingPolicies)
{
if (policyPairing.PolicyId == assignmentPolicy.Id)
{
foreach (var scope in blScopes)
{
if (scope.Id == policyPairing.ScopeId)
{
blScopes.Add(scope);
break;
}
}
}
}
var assignmentPolicyModel = new AssignmentPolicyModel()
{
Name = assignmentPolicy.Name,
Default = assignmentPolicy.IsDefault,
RequiredAccountType = role,
AssignedScopes = blScopes,
Priority = assignmentPolicy.Priority
};
return(Result <AssignmentPolicyModel> .Success(assignmentPolicyModel));
}
