public async Task <MergePolicyEvaluationResult> EvaluateAsync(
string prUrl,
IRemote darc,
IReadOnlyList <MergePolicyDefinition> policyDefinitions)
{
var context = new MergePolicyEvaluationContext(prUrl, darc);
foreach (MergePolicyDefinition definition in policyDefinitions)
{
if (MergePolicies.TryGetValue(definition.Name, out MergePolicy policy))
{
using (Logger.BeginScope("Evaluating Merge Policy {policyName}", policy.Name))
{
context.CurrentPolicy = policy;
await policy.EvaluateAsync(context, new MergePolicyProperties(definition.Properties));
}
}
else
{
context.CurrentPolicy = null;
context.Fail($"Unknown Merge Policy: '{definition.Name}'");
}
}
return(context.Result);
}
public async Task <IActionResult> MergePolicies([FromBody] MergePolicies merge)
{
var scope = AuthenticationService.GetScope(User);
var result = await PolicyService.MergePolicies(scope, merge);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task MergePolicies()
{
var policy = new PolicyEdit()
{
Id = Guid.NewGuid(),
};
var merge = new MergePolicies()
{
TargetPolicy = policy,
SourcePolicyIds = new List <Guid>()
{
Guid.NewGuid(), Guid.NewGuid()
}
};
var service = new Mock <IPolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
MergePolicies merged = null;
service.Setup(c => c.MergePolicies(It.IsAny <ScopeOptions>(), It.Is <MergePolicies>(m => m == merge)))
.Callback((ScopeOptions o, MergePolicies m) =>
{
merged = m;
options = o;
})
.ReturnsAsync(result);
var controller = new MergeController(null, service.Object, authService.Object);
var actual = await controller.MergePolicies(merge);
Assert.Same(merge, merged);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async Task <Result> MergePolicies(ScopeOptions scope, MergePolicies merge)
{
var clientValidator = new PolicyValidator(_context, scope, true);
var result = clientValidator.Validate(merge.TargetPolicy, ruleSet: "default").GetResult();
if (!result.Success)
{
return(result);
}
var mergeValidator = new MergePoliciesValidator(_context, scope);
result = mergeValidator.Validate(merge).GetResult();
if (!result.Success)
{
return(result);
}
var strategy = _context.Database.CreateExecutionStrategy();
result = await strategy.ExecuteAsync <Result>(async() =>
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
//Insert the 'new' policy
var entity = MapModelToEntity(merge.TargetPolicy);
await _context.Policy.AddAsync(entity);
await _context.SaveChangesAsync();
merge.TargetPolicy.Id = entity.Id;
//Move dependancies to the new policy ----------------------------------------------------
//1. Commissions
var commmissions = await _context.Commission.Where(p => merge.SourcePolicyIds.Contains(p.PolicyId)).ToListAsync();
foreach (var commmission in commmissions)
{
commmission.PolicyId = merge.TargetPolicy.Id.Value;
}
//2. Commission Errors
var commissionErrors = await _context.CommissionError.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId.Value)).ToListAsync();
foreach (var commissionError in commissionErrors)
{
commissionError.PolicyId = merge.TargetPolicy.Id.Value;
}
//3. Commission Split Rule Policies
var commissionSplitRulePolicies = await _context.CommissionSplitRulePolicy.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId)).ToListAsync();
foreach (var commissionSplitRulePolicy in commissionSplitRulePolicies)
{
commissionSplitRulePolicy.PolicyId = merge.TargetPolicy.Id.Value;
}
//4. Commission Allocation Policies
var commissionAllocationPolicies = await _context.CommissionAllocationPolicy.Where(c => merge.SourcePolicyIds.Contains(c.PolicyId)).ToListAsync();
foreach (var commissionAllocationPolicy in commissionAllocationPolicies)
{
commissionAllocationPolicy.PolicyId = merge.TargetPolicy.Id.Value;
}
await _context.SaveChangesAsync();
//----------------------------------------------------------------------------------------
//Delete 'old' policies
var policiesToDelete = await _context.Policy.Where(m => merge.SourcePolicyIds.Contains(m.Id)).ToListAsync();
foreach (var policyToDelete in policiesToDelete)
{
_context.Remove(policyToDelete);
}
await _context.SaveChangesAsync();
//Commit
await transaction.CommitAsync();
return(new Result(true));
}
catch
{
transaction.Rollback();
return(new Result(false));
}
}
});
result.Tag = merge.TargetPolicy;
await _auditService.InsertAuditLog(scope, "Merge", "Policy", merge.TargetPolicy.Id, merge);
return(result);
}
