public async Task GetCommissionSplitRulePolicy()
{
var options = TestHelper.GetDbContext("GetCommissionSplitRulePolicy");
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 csr1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = Guid.NewGuid()
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.CommissionSplitRulePolicy.Add(csr1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var commissionSplitService = new CommissionSplitService(context, auditService);
var service = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var actual = await service.GetCommissionSplitRulePolicy(scope, csr1.PolicyId);
//Then
Assert.Equal(csr1.Id, actual.Id);
Assert.Equal(csr1.PolicyId, actual.PolicyId);
Assert.Equal(csr1.CommissionSplitRuleId, actual.CommissionSplitRuleId);
//Check scope
scope = TestHelper.GetScopeOptions(user2);
actual = await service.GetCommissionSplitRulePolicy(scope, csr1.PolicyId);
Assert.Null(actual.CommissionSplitRuleId);
}
}
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 DeleteCommissionSplitRule()
{
var options = TestHelper.GetDbContext("DeleteCommissionSplitRule");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var user3 = TestHelper.InsertUserDetailed(options);
var csr1 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "Com Split Rule 1",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var csrp1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionSplitRuleId = csr1.Id
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user2.User.Id,
Name = "Com Split Rule 2",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 100
}
}
};
var csr3 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user3.User.Id,
Name = "Com Split Rule 3",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user3.User.Id,
Percentage = 100
}
}
};
using (var context = new DataContext(options))
{
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRule.Add(csr1);
context.CommissionSplitRule.Add(csr3);
context.CommissionSplitRulePolicy.Add(csrp1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionSplitService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.DeleteCommissionSplitRule(scope, csr1.Id);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRule.FindAsync(csr1.Id);
Assert.Null(actual);
var actualDep = await context.CommissionSplitRulePolicy.FindAsync(csrp1.Id);
Assert.Null(actualDep);
//Out of scope
scope = TestHelper.GetScopeOptions(user3, Scope.User);
result = await service.DeleteCommissionSplitRule(scope, csr2.Id);
Assert.False(result.Success);
actual = await context.CommissionSplitRule.FindAsync(csr2.Id);
Assert.NotNull(actual);
}
}
public async Task ImportCommission_InsertCommission_Split_Specific()
{
var options = TestHelper.GetDbContext("ImportCommission_InsertCommission_Split_Specific");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var user3 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var company = TestHelper.InsertCompany(options);
var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation, company.Id);
var commissionType = new CommissionTypeEntity
{
Id = Guid.NewGuid(),
Code = "gap_cover"
};
var policy1 = new PolicyEntity
{
Id = Guid.NewGuid(),
Number = Guid.NewGuid().ToString(),
CompanyId = company.Id,
ClientId = client1.Client.Id,
UserId = user1.User.Id,
NumberAliases = new List <string>(),
};
var csr1 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "75/25 split",
IsDefault = true, //Default
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 75
},
new CommissionSplit()
{
UserId = user3.User.Id,
Percentage = 25
}
}
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "50/50 split",
IsDefault = false, //Not Default
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 50
},
new CommissionSplit()
{
UserId = user3.User.Id,
Percentage = 50
}
}
};
var csrp1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy1.Id,
CommissionSplitRuleId = csr2.Id
};
using (var context = new DataContext(options))
{
context.CommissionType.Add(commissionType);
context.Policy.Add(policy1);
context.CommissionSplitRule.Add(csr1);
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRulePolicy.Add(csrp1);
context.SaveChanges();
var auditService = new AuditServiceMock();
var statementService = new CommissionStatementService(context, null, auditService);
var lookupService = new DirectoryLookupService(context);
var commissionLookupService = new CommissionLookupService(context);
var policyService = new PolicyService(context, auditService);
var commissionSplitService = new CommissionSplitService(context, auditService);
var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService);
var commissionService = new CommissionService(context, auditService);
var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict);
var insertedCommissions = new List <CommissionEntity>();
bulkActions.Setup(c => c.BulkInsertCommissionsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionEntity> >()))
.Callback((DataContext c, IList <CommissionEntity> l) => insertedCommissions = l.ToList())
.Returns(Task.CompletedTask);
var service = new CommissionImportService(
context,
bulkActions.Object,
statementService,
policyService,
lookupService,
commissionLookupService,
commissionSplitService,
commissionSplitRulePolicyService,
auditService);
//When
var import1 = new ImportCommission
{
PolicyNumber = policy1.Number,
CommissionTypeCode = commissionType.Code,
AmountIncludingVAT = "120",
VAT = "12"
};
var scope = TestHelper.GetScopeOptions(user1);
var importResult = (await service.ImportCommissions(scope, statement.Id, new List <ImportCommission>()
{
import1
}));
var result = importResult.Results.Single();
//Then
Assert.True(result.Success);
Assert.Equal(2, insertedCommissions.Count);
var actual = insertedCommissions[0];
Assert.Equal(policy1.Id, actual.PolicyId);
Assert.Equal(commissionType.Id, actual.CommissionTypeId);
Assert.Equal(60, actual.AmountIncludingVAT);
Assert.Equal(6, actual.VAT);
Assert.Equal(statement.Id, actual.CommissionStatementId);
Assert.Equal(import1, actual.SourceData);
actual = insertedCommissions[1];
Assert.Equal(policy1.Id, actual.PolicyId);
Assert.Equal(commissionType.Id, actual.CommissionTypeId);
Assert.Equal(60, actual.AmountIncludingVAT);
Assert.Equal(6, actual.VAT);
Assert.Equal(statement.Id, actual.CommissionStatementId);
Assert.Equal(import1, actual.SourceData);
}
}
public async Task DeleteCommissionSplitRulePolicy()
{
var options = TestHelper.GetDbContext("DeleteCommissionSplitRulePolicy");
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 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.CommissionSplitRulePolicy.Add(csrp1);
context.CommissionSplitRulePolicy.Add(csrp2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionSplitRulePolicyService(context, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.DeleteCommissionSplitRulePolicy(scope, csrp2.Id);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRulePolicy.FindAsync(csrp2.Id);
Assert.Null(actual);
//Out of scope
scope = TestHelper.GetScopeOptions(user2, Scope.User);
result = await service.DeleteCommissionSplitRulePolicy(scope, csrp1.Id);
Assert.False(result.Success);
actual = await context.CommissionSplitRulePolicy.FindAsync(csrp1.Id);
Assert.NotNull(actual);
}
}
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);
}
}
public async Task GetCommissionSplitRulePolicies()
{
var options = TestHelper.GetDbContext("GetCommissionSplitRulePolicies");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var client2 = TestHelper.InsertClient(options, user1.Organisation);
var user3 = TestHelper.InsertUserDetailed(options);
var client3 = TestHelper.InsertClient(options, user3.Organisation);
//Given
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 = client2.Client.Id,
UserId = user2.User.Id,
Number = "654321",
};
var policy3 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
ClientId = client2.Client.Id,
UserId = user2.User.Id,
Number = "987654"
};
var policy4 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
ClientId = client3.Client.Id,
UserId = user3.User.Id,
Number = "987654"
};
var csr1 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "Com Split Rule 1",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user2.User.Id,
Name = "Com Split Rule 2",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 100
}
}
};
var csr3 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user2.User.Id,
Name = "Com Split Rule 3",
IsDefault = false,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 100
}
}
};
var csrp1 = new CommissionSplitRulePolicyEntity
{
Id = Guid.NewGuid(),
PolicyId = policy2.Id,
CommissionSplitRuleId = csr3.Id
};
using (var context = new DataContext(options))
{
context.Policy.Add(policy1);
context.Policy.Add(policy2);
context.Policy.Add(policy3);
context.Policy.Add(policy4);
context.CommissionSplitRule.Add(csr1);
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRule.Add(csr3);
context.CommissionSplitRulePolicy.Add(csrp1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionSplitRulePolicyService(context, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var queryOptions = new CommissionSplitRulePolicyInfoQueryOptions(scope, "", "", 0, 0);
var rules = await service.GetCommissionSplitRulePolicyInfoList(queryOptions);
//Then
Assert.Equal(3, rules.TotalItems);
Assert.Equal(3, rules.Items.Count());
var items = rules.Items.ToList();
var actual = items[0];
Assert.Equal(policy1.Id, actual.PolicyId);
Assert.Equal(policy1.Number, actual.PolicyNumber);
Assert.Equal(policy1.UserId, actual.PolicyUserId);
Assert.Equal(policy1.CompanyId, actual.PolicyCompanyId);
Assert.Equal(client1.Client.Id, actual.PolicyClientId);
Assert.Equal(client1.Client.FirstName, actual.PolicyClientFirstName);
Assert.Equal(client1.Client.LastName, actual.PolicyClientLastName);
Assert.Null(actual.CommissionSplitRuleId);
Assert.Null(actual.CommissionSplitRuleName);
Assert.Equal(csr1.Id, actual.DefaultCommissionSplitRuleId);
Assert.Equal(csr1.Name, actual.DefaultCommissionSplitRuleName);
actual = items[1];
Assert.Equal(policy2.Id, actual.PolicyId);
Assert.Equal(policy2.Number, actual.PolicyNumber);
Assert.Equal(policy2.UserId, actual.PolicyUserId);
Assert.Equal(policy2.CompanyId, actual.PolicyCompanyId);
Assert.Equal(client2.Client.Id, actual.PolicyClientId);
Assert.Equal(client2.Client.FirstName, actual.PolicyClientFirstName);
Assert.Equal(client2.Client.LastName, actual.PolicyClientLastName);
Assert.Equal(csrp1.CommissionSplitRuleId, actual.CommissionSplitRuleId);
Assert.Equal(csr3.Name, actual.CommissionSplitRuleName);
Assert.Equal(csr2.Id, actual.DefaultCommissionSplitRuleId);
Assert.Equal(csr2.Name, actual.DefaultCommissionSplitRuleName);
actual = items[2];
Assert.Equal(policy3.Id, actual.PolicyId);
Assert.Null(actual.CommissionSplitRuleId);
Assert.Null(actual.CommissionSplitRuleName);
Assert.Equal(csr2.Id, actual.DefaultCommissionSplitRuleId);
Assert.Equal(csr2.Name, actual.DefaultCommissionSplitRuleName);
//Check scope
scope = TestHelper.GetScopeOptions(user3, Scope.Organisation);
queryOptions = new CommissionSplitRulePolicyInfoQueryOptions(scope, "", "", 0, 0);
rules = await service.GetCommissionSplitRulePolicyInfoList(queryOptions);
Assert.Single(rules.Items);
actual = rules.Items.Single();
Assert.Equal(policy4.Id, actual.PolicyId);
Assert.Null(actual.CommissionSplitRuleId);
Assert.Null(actual.DefaultCommissionSplitRuleId);
}
}
