private CommissionSplitRulePolicyEntity MapModelToEntity(CommissionSplitRulePolicy model, CommissionSplitRulePolicyEntity entity = null)
{
if (entity == null)
{
entity = new CommissionSplitRulePolicyEntity();
}
entity.PolicyId = model.PolicyId.Value;
entity.CommissionSplitRuleId = model.CommissionSplitRuleId.Value;
return(entity);
}
public async Task <IActionResult> Insert([FromBody] CommissionSplitRulePolicy commissionSplitRulePolicy)
{
var scope = AuthenticationService.GetScope(User);
var result = await CommissionSplitRulePolicyService.InsertCommissionSplitRulePolicy(scope, commissionSplitRulePolicy);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task Update()
{
var rule = new CommissionSplitRulePolicy()
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionSplitRuleId = Guid.NewGuid()
};
var service = new Mock <ICommissionSplitRulePolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
CommissionSplitRulePolicy updated = null;
service.Setup(c => c.UpdateCommissionSplitRulePolicy(It.IsAny <ScopeOptions>(), It.IsAny <CommissionSplitRulePolicy>()))
.Callback((ScopeOptions o, CommissionSplitRulePolicy i) =>
{
updated = i;
options = o;
})
.ReturnsAsync(result);
var controller = new CommissionSplitRulePoliciesController(service.Object, authService.Object);
var actual = await controller.Update(rule.Id.Value, rule);
Assert.Same(rule, updated);
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 Get()
{
var rule = new CommissionSplitRulePolicy()
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionSplitRuleId = Guid.NewGuid()
};
var service = new Mock <ICommissionSplitRulePolicyService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetCommissionSplitRulePolicy(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == rule.Id.Value)))
.ReturnsAsync(rule);
var controller = new CommissionSplitRulePoliciesController(service.Object, authService.Object);
var result = await controller.Get(rule.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <CommissionSplitRulePolicy>(okResult.Value);
Assert.Same(rule, returnValue);
}
public async Task <Result> UpdateCommissionSplitRulePolicy(ScopeOptions scope, CommissionSplitRulePolicy commissionSplitRulePolicy)
{
var validator = new CommissionSplitRulePolicyValidator(_context, scope, false);
var result = validator.Validate(commissionSplitRulePolicy).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetCommissionSplitRulePolicyEntityQuery(scope).FirstOrDefaultAsync(b => b.Id == commissionSplitRulePolicy.Id);
if (entity == null)
{
return(new Result());
}
var defaultRule = await GetDefaultCommissionSplitRule(scope, commissionSplitRulePolicy.PolicyId.Value);
//If this is the default rule, then remove this instance
if (defaultRule != null && commissionSplitRulePolicy.CommissionSplitRuleId == defaultRule.Id)
{
await DeleteCommissionSplitRulePolicy(scope, commissionSplitRulePolicy.Id.Value);
return(result);
}
var commissionSplitRulePolicyEntity = MapModelToEntity(commissionSplitRulePolicy, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "CommissionSplitRulePolicy", entity.Id, commissionSplitRulePolicy);
return(result);
}
public async Task <Result> InsertCommissionSplitRulePolicy(ScopeOptions scope, CommissionSplitRulePolicy commissionSplitRulePolicy)
{
var validator = new CommissionSplitRulePolicyValidator(_context, scope, true);
var result = validator.Validate(commissionSplitRulePolicy).GetResult();
if (!result.Success)
{
return(result);
}
var defaultRule = await GetDefaultCommissionSplitRule(scope, commissionSplitRulePolicy.PolicyId.Value);
//If the rule is already the default dont add it
if (defaultRule != null && commissionSplitRulePolicy.CommissionSplitRuleId == defaultRule.Id)
{
return(result);
}
var entity = MapModelToEntity(commissionSplitRulePolicy);
await _context.CommissionSplitRulePolicy.AddAsync(entity);
await _context.SaveChangesAsync();
commissionSplitRulePolicy.Id = entity.Id;
result.Tag = commissionSplitRulePolicy;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "CommissionSplitRulePolicy", entity.Id, commissionSplitRulePolicy);
return(result);
}
public async Task UpdateCommissionSplitRule_IsDefault_Deleted()
{
var options = TestHelper.GetDbContext("UpdateCommissionSplitRule_IsDefault_Deleted");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
ClientId = client1.Client.Id,
UserId = user1.User.Id,
Number = "123465",
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "Com Split Rule 2",
IsDefault = true, //Is Default
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var csrp1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = Guid.NewGuid()
};
var csrp2 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = Guid.NewGuid()
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRulePolicy.Add(csrp1);
context.CommissionSplitRulePolicy.Add(csrp2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var csrp2Updated = new CommissionSplitRulePolicy
{
Id = csrp2.Id,
PolicyId = policy1.Id,
CommissionSplitRuleId = csr2.Id
};
var auditService = new AuditServiceMock();
var commissionSplitService = new CommissionSplitService(context, auditService);
var service = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateCommissionSplitRulePolicy(scope, csrp2Updated);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRulePolicy.FindAsync(csrp2Updated.Id);
Assert.Null(actual);
actual = await context.CommissionSplitRulePolicy.FindAsync(csrp1.Id);
Assert.NotNull(actual);
}
}
public async Task UpdateCommissionSplitRule()
{
var options = TestHelper.GetDbContext("UpdateCommissionSplitRule");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
ClientId = client1.Client.Id,
UserId = user1.User.Id,
Number = "123465",
};
var policy2 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
ClientId = client1.Client.Id,
UserId = user1.User.Id,
Number = "123465",
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "Com Split Rule 2",
IsDefault = false,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var csrp1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = Guid.NewGuid()
};
var csrp2 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = Guid.NewGuid()
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.Policy.Add(policy2);
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRulePolicy.Add(csrp1);
context.CommissionSplitRulePolicy.Add(csrp2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var csrp2Updated = new CommissionSplitRulePolicy
{
Id = csrp2.Id,
PolicyId = policy2.Id,
CommissionSplitRuleId = csr2.Id
};
var auditService = new AuditServiceMock();
var commissionSplitService = new CommissionSplitService(context, auditService);
var service = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateCommissionSplitRulePolicy(scope, csrp2Updated);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRulePolicy.FindAsync(csrp2Updated.Id);
Assert.Equal(csrp2Updated.Id, actual.Id);
Assert.Equal(csrp2Updated.PolicyId, actual.PolicyId);
Assert.Equal(csrp2Updated.CommissionSplitRuleId, actual.CommissionSplitRuleId);
//Out of scope
scope = TestHelper.GetScopeOptions(user2, Scope.User);
result = await service.InsertCommissionSplitRulePolicy(scope, csrp2Updated);
Assert.False(result.Success);
Assert.Equal("'Policy' does not exist.", result.ValidationFailures.First().ErrorMessage);
}
}
