public async Task <int> UpdateAssignmentPolicyPairing(AssignmentPolicyPairingModel model)
{
var storedProcedure = "dbo.AssignmentPolicyPairing_Update";
return(await _dataGateway.Execute(storedProcedure,
new
{
Id = model.Id,
policyId = model.PolicyId,
scopeId = model.ScopeId
},
_connectionString.SqlConnectionString));
}
public async Task <int> CreateAssignmentPolicyPairing(AssignmentPolicyPairingModel model)
{
var storedProcedure = "dbo.AssignmentPolicyPairing_Create";
DynamicParameters p = new DynamicParameters();
p.Add("policyId", model.PolicyId);
p.Add("scopeId", model.ScopeId);
p.Add("Id", DbType.Int32, direction: ParameterDirection.Output);
await _dataGateway.Execute(storedProcedure, p, _connectionString.SqlConnectionString);
return(p.Get <int>("Id"));
}
public async Task Init()
{
await TestCleaner.CleanDatabase();
var numTestRows = 20;
IDataGateway dataGateway = new SQLServerGateway();
IConnectionStringData connectionString = new ConnectionStringData();
IScopeRepository scopeRepository = new ScopeRepository(dataGateway, connectionString);
IAssignmentPolicyRepository assignmentPolicyRepository = new AssignmentPolicyRepository(dataGateway, connectionString);
IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(dataGateway, connectionString);
for (int i = 1; i <= numTestRows; ++i)
{
ScopeModel scopeModel = new ScopeModel();
scopeModel.Id = i;
scopeModel.Type = "TestScope" + i;
scopeModel.Description = "TestDescription" + i;
var scopeId = await scopeRepository.CreateScope(scopeModel);
scopeModel.IsDefault = true;
AssignmentPolicyModel assignmentPolicyModel = new AssignmentPolicyModel();
assignmentPolicyModel.Id = i;
assignmentPolicyModel.Name = "TestClaim" + i;
assignmentPolicyModel.IsDefault = true;
assignmentPolicyModel.RequiredAccountType = "TestAccountType" + i;
assignmentPolicyModel.Priority = i % 4;
var policyId = await assignmentPolicyRepository.CreateAssignmentPolicy(assignmentPolicyModel);
AssignmentPolicyPairingModel assignmentPolicyPairingModel = new AssignmentPolicyPairingModel();
assignmentPolicyPairingModel.Id = i;
assignmentPolicyPairingModel.PolicyId = policyId;
assignmentPolicyPairingModel.ScopeId = scopeId;
await assignmentPolicyPairingRepository.CreateAssignmentPolicyPairing(assignmentPolicyPairingModel);
}
}
public async Task UpdateAssignmentPolicyPairing_AssignmentPolicyPairingExists_AssignmentPolicyPairingValuesAccurate(int id, int expectedPolicyId, int expectedScopeId)
{
// Arrange
IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(new SQLServerGateway(), new ConnectionStringData());
AssignmentPolicyPairingModel assignmentPolicyPairingModel = new AssignmentPolicyPairingModel();
assignmentPolicyPairingModel.Id = id;
assignmentPolicyPairingModel.PolicyId = expectedPolicyId;
assignmentPolicyPairingModel.ScopeId = expectedScopeId;
// Act
await assignmentPolicyPairingRepository.UpdateAssignmentPolicyPairing(assignmentPolicyPairingModel);
var actual = await assignmentPolicyPairingRepository.GetAssignmentPolicyPairingById(id);
var actualPolicyId = actual.PolicyId;
var actualScopeId = actual.ScopeId;
// Assert
Assert.IsTrue(actualPolicyId == expectedPolicyId &&
actualScopeId == expectedScopeId);
}
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));
}
