public async Task InsertAdviceService()
{
var options = TestHelper.GetDbContext("InsertAdviceService");
//Given
var model = new AdviceService()
{
Name = "1",
DisplayOrder = 1
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.InsertAdviceService(model);
//Then
Assert.True(result.Success);
var actual = await context.AdviceService.FindAsync(((AdviceService)result.Tag).Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.DisplayOrder, actual.DisplayOrder);
}
}
public async Task ImportClient_Insert_WithAlternateIdNumber()
{
var options = TestHelper.GetDbContext("ImportClient_Insert_WithAlternateIdNumber");
var user1 = TestHelper.InsertUserDetailed(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "123456" //Not a valid id number so should be treated as a passport number
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.AlternateIdNumber == data.IdNumber);
Assert.Null(actual.IdNumber);
}
}
public async Task InsertCompany()
{
var options = TestHelper.GetDbContext("InsertCompany");
//Given
var model = new Company()
{
Name = "1",
CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_1"
}
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.InsertCompany(model);
//Then
Assert.True(result.Success);
var actual = await context.Company.FindAsync(((Company)result.Tag).Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.CommissionPolicyNumberPrefixes, actual.CommissionPolicyNumberPrefixes);
}
}
public async Task ImportClient_Update_LastNameAndDateOfBirth()
{
var options = TestHelper.GetDbContext("ImportClient_Update_LastNameAndDateOfBirth");
var user1 = TestHelper.InsertUserDetailed(options);
var mem1 = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL,
OrganisationId = user1.Organisation.Id
};
var mem2 = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL,
FirstName = "FN 1",
LastName = "van Jones",
IdNumber = "8210035032082",
DateOfBirth = new DateTime(1982, 10, 3),
OrganisationId = user1.Organisation.Id
};
using (var context = new DataContext(options))
{
context.Client.Add(mem1);
context.Client.Add(mem2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
FirstName = "FN 1 Updated",
LastName = mem2.LastName,
DateOfBirth = mem2.DateOfBirth
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == mem2.IdNumber);
Assert.Equal(data.FirstName, actual.FirstName);
}
}
public async Task InsertLicenseCategory()
{
var options = TestHelper.GetDbContext("InsertLicenseCategory");
//Given
var model = new LicenseCategory()
{
Name = "1",
Code = "A",
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.InsertLicenseCategory(model);
//Then
Assert.True(result.Success);
var actual = await context.LicenseCategory.FindAsync(((LicenseCategory)result.Tag).Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.Code, actual.Code);
}
}
public async Task ImportClient_Insert_With3MissingZeroOnIdNumber()
{
var options = TestHelper.GetDbContext("ImportClient_Insert_With3MissingZeroOnIdNumber");
var user1 = TestHelper.InsertUserDetailed(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "7287372085" //missing leading zero
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == "0007287372085");
Assert.NotNull(actual);
}
}
public async Task GetCompanies()
{
var options = TestHelper.GetDbContext("GetCompanies");
//Given
var lkp1 = new CompanyEntity {
Id = Guid.NewGuid(), Name = "A", CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_1"
}
};
var lkp2 = new CompanyEntity {
Id = Guid.NewGuid(), Name = "B", CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_2"
}
};
var lkp3 = new CompanyEntity {
Id = Guid.NewGuid(), Name = "C", CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_3"
}
};
using (var context = new DataContext(options))
{
//Jumbled order
context.Company.Add(lkp2);
context.Company.Add(lkp1);
context.Company.Add(lkp3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var actual = await service.GetCompanies();
//Then
Assert.Equal(3, actual.Count);
var actual1 = actual[0];
Assert.Equal(lkp1.Id, actual1.Id);
Assert.Equal(lkp1.Name, actual1.Name);
Assert.Equal(lkp1.CommissionPolicyNumberPrefixes, actual1.CommissionPolicyNumberPrefixes);
var actual2 = actual[1];
Assert.Equal(lkp2.Id, actual2.Id);
var actual3 = actual[2];
Assert.Equal(lkp3.Id, actual3.Id);
}
}
public async Task ImportClient_InsertPolicy_CheckUserAlias()
{
var options = TestHelper.GetDbContext("ImportClient_InsertPolicy_CheckUserAlias");
var organisation = TestHelper.InsertOrganisation(options);
var user = new UserEdit
{
Id = Guid.NewGuid(),
FirstName = "Dean",
LastName = "van Niekerk",
Aliases = new List <string>()
{
"DJVANNiekerk"
}
};
var user1 = TestHelper.InsertUserDetailed(options, organisation, user);
var company = TestHelper.InsertCompany(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var policyService = new PolicyService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, policyService, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "12345",
LastName = "LN",
PolicyNumber = "987654",
PolicyCompanyId = company.Id,
PolicyUserFullName = "DjvanNiekerk"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Policy.FirstOrDefaultAsync(m => m.Number == data.PolicyNumber);
Assert.Equal(data.PolicyCompanyId, actual.CompanyId);
Assert.Equal(user1.User.Id, actual.UserId);
}
}
public async Task ImportClient_Update_MatchOnShortIdNumber()
{
var options = TestHelper.GetDbContext("ImportClient_Update_MatchOnShortIdNumber");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var mem = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL,
LastName = "LN 1",
IdNumber = "8201015800184",
OrganisationId = user1.Organisation.Id
};
using (var context = new DataContext(options))
{
context.Client.Add(mem);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "8201015800085",
LastName = "LN updated",
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.Id == mem.Id);
Assert.Equal(user1.Organisation.Id, actual.OrganisationId);
Assert.Equal(data.LastName, actual.LastName);
}
}
public async Task ImportClient_InsertPolicy()
{
var options = TestHelper.GetDbContext("ImportClient_InsertPolicy");
var user1 = TestHelper.InsertUserDetailed(options);
var policyType1 = TestHelper.InsertPolicyType(options);
var policyType2 = TestHelper.InsertPolicyType(options);
var company = TestHelper.InsertCompany(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var policyService = new PolicyService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, policyService, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "12345",
LastName = "LN",
PolicyNumber = "987654",
PolicyCompanyId = company.Id,
PolicyTypeCode = policyType2.Code,
PolicyPremium = 5000,
PolicyStartDate = DateTime.Now,
PolicyUserFullName = $"{user1.User.FirstName} {user1.User.LastName}"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Policy.FirstOrDefaultAsync(m => m.Number == data.PolicyNumber);
Assert.Equal(data.PolicyCompanyId, actual.CompanyId);
Assert.Equal(user1.User.Id, actual.UserId);
Assert.Equal(data.PolicyPremium, actual.Premium);
Assert.Equal(data.PolicyStartDate, actual.StartDate);
Assert.Equal(policyType2.Id, actual.PolicyTypeId);
}
}
public async Task ImportClient_Update_WithAlternateIdNumber()
{
var options = TestHelper.GetDbContext("ImportClient_Update_WithAlternateIdNumber");
var user1 = TestHelper.InsertUserDetailed(options);
var mem = new ClientEntity
{
Id = Guid.NewGuid(),
FirstName = "FN 1",
LastName = "LN 1",
AlternateIdNumber = "123456",
OrganisationId = user1.Organisation.Id
};
using (var context = new DataContext(options))
{
context.Client.Add(mem);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "123456", //Not a valid id number so should be treated as a passport number
LastName = "LN updated"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.AlternateIdNumber == data.IdNumber);
Assert.Equal(data.LastName, actual.LastName);
}
}
public async Task ImportClient_Update_MatchOnPolicyNumber()
{
var options = TestHelper.GetDbContext("ImportClient_Update_MatchOnPolicyNumber");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var client2 = TestHelper.InsertClient(options, user1.Organisation);
var client1 = TestHelper.InsertClient(options, user1.Organisation, "8210035032082");
var company = TestHelper.InsertCompany(options);
var policy2 = TestHelper.InsertPolicy(options, client2, user1, company.Id);
var policy1 = TestHelper.InsertPolicy(options, client1, user1, company.Id);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var policyService = new PolicyService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, policyService, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "",
LastName = "LN updated",
PolicyNumber = policy1.Number,
PolicyCompanyId = company.Id,
PolicyUserFullName = user1.User.FirstName + " " + user1.User.LastName
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.Id == client1.Client.Id);
Assert.Equal(user1.Organisation.Id, actual.OrganisationId);
Assert.Equal(data.LastName, actual.LastName);
}
}
public async Task GetUserTypes()
{
var options = TestHelper.GetDbContext("GetUserTypes");
//Given
var lkp1 = new UserTypeEntity {
Id = Guid.NewGuid(), Name = "A", DisplayOrder = 1
};
var lkp2 = new UserTypeEntity {
Id = Guid.NewGuid(), Name = "B", DisplayOrder = 2
};
var lkp3 = new UserTypeEntity {
Id = Guid.NewGuid(), Name = "C", DisplayOrder = 3
};
using (var context = new DataContext(options))
{
//Jumbled order
context.UserType.Add(lkp2);
context.UserType.Add(lkp1);
context.UserType.Add(lkp3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var actual = await service.GetUserTypes();
//Then
Assert.Equal(3, actual.Count);
var actual1 = actual[0];
Assert.Equal(lkp1.Id, actual1.Id);
Assert.Equal(lkp1.Name, actual1.Name);
Assert.Equal(lkp1.DisplayOrder, actual1.DisplayOrder);
var actual2 = actual[1];
Assert.Equal(lkp2.Id, actual2.Id);
var actual3 = actual[2];
Assert.Equal(lkp3.Id, actual3.Id);
}
}
public async Task GetLicenseCategories()
{
var options = TestHelper.GetDbContext("GetLicenseCategories");
//Given
var lkp1 = new LicenseCategoryEntity {
Id = Guid.NewGuid(), Name = "A", Code = "1.0"
};
var lkp2 = new LicenseCategoryEntity {
Id = Guid.NewGuid(), Name = "B", Code = "2.0"
};
var lkp3 = new LicenseCategoryEntity {
Id = Guid.NewGuid(), Name = "C", Code = "3.0"
};
using (var context = new DataContext(options))
{
//Jumbled order
context.LicenseCategory.Add(lkp2);
context.LicenseCategory.Add(lkp1);
context.LicenseCategory.Add(lkp3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var actual = await service.GetLicenseCategories();
//Then
Assert.Equal(3, actual.Count);
var actual1 = actual[0];
Assert.Equal(lkp1.Id, actual1.Id);
Assert.Equal(lkp1.Name, actual1.Name);
Assert.Equal(lkp1.Code, actual1.Code);
var actual2 = actual[1];
Assert.Equal(lkp2.Id, actual2.Id);
var actual3 = actual[2];
Assert.Equal(lkp3.Id, actual3.Id);
}
}
public async Task UpdateCompany()
{
var options = TestHelper.GetDbContext("UpdateCompany");
//Given
var lkp1 = new CompanyEntity {
Id = Guid.NewGuid(), Name = "1", CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_1"
}
};
using (var context = new DataContext(options))
{
context.Company.Add(lkp1);
context.SaveChanges();
}
var model = new Company()
{
Id = lkp1.Id,
Name = "1 Updated",
CommissionPolicyNumberPrefixes = new List <string>()
{
"pre_1", "pre_new"
}
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.UpdateCompany(model);
//Then
Assert.True(result.Success);
var actual = await context.Company.FindAsync(model.Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.CommissionPolicyNumberPrefixes, actual.CommissionPolicyNumberPrefixes);
}
}
public async Task ImportClient_Insert()
{
var options = TestHelper.GetDbContext("ImportClient_Insert");
var user1 = TestHelper.InsertUserDetailed(options);
var clientType = TestHelper.InsertClientTypeIndividual(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "821003 5032 082",
FirstName = "FN",
LastName = "LN",
TaxNumber = "987654",
DateOfBirth = DateTime.Now,
ClientTypeCode = clientType.Code
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == "8210035032082");
Assert.Null(actual.AlternateIdNumber);
Assert.Equal(clientType.Id, actual.ClientTypeId);
Assert.Equal(user1.Organisation.Id, actual.OrganisationId);
Assert.Equal(data.LastName, actual.LastName);
Assert.Equal(data.FirstName, actual.FirstName);
Assert.Equal(data.TaxNumber, actual.TaxNumber);
Assert.Equal(data.DateOfBirth, actual.DateOfBirth);
}
}
public async Task ImportClient_Insert_NoIdButHasPolicyNumber_UnknowClientType()
{
var options = TestHelper.GetDbContext("ImportClient_Insert_NoIdButHasPolicyNumber_UnknowClientType");
var user1 = TestHelper.InsertUserDetailed(options);
var company = TestHelper.InsertCompany(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var policyService = new PolicyService(context, auditService);
var contactService = new ContactService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, policyService, contactService, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "",
PolicyNumber = "123456798",
LastName = "Some Business",
PolicyCompanyId = company.Id,
PolicyUserFullName = user1.User.FirstName + " " + user1.User.LastName
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync();
Assert.Null(actual.IdNumber);
Assert.Equal(data.LastName, actual.LastName);
Assert.Equal(ClientType.CLIENT_TYPE_UNKNOWN_ENTITY, actual.ClientTypeId);
}
}
public async Task UpdateLicenseCategory()
{
var options = TestHelper.GetDbContext("UpdateLicenseCategory");
//Given
var lkp1 = new LicenseCategoryEntity {
Id = Guid.NewGuid(), Name = "1", Code = "A"
};
using (var context = new DataContext(options))
{
context.LicenseCategory.Add(lkp1);
context.SaveChanges();
}
var model = new LicenseCategory()
{
Id = lkp1.Id,
Name = "1 Updated",
Code = "A Updated",
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.UpdateLicenseCategory(model);
//Then
Assert.True(result.Success);
var actual = await context.LicenseCategory.FindAsync(model.Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.Code, actual.Code);
}
}
public async Task ImportClient_InsertUnknownEntity()
{
var options = TestHelper.GetDbContext("ImportClient_InsertUnknownEntity");
var user1 = TestHelper.InsertUserDetailed(options);
var clientType = TestHelper.InsertClientTypeUnknown(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
LastName = "Unknown Here",
ClientTypeCode = clientType.Code
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync();
Assert.Null(actual.AlternateIdNumber);
Assert.Null(actual.FirstName);
Assert.Equal(clientType.Id, actual.ClientTypeId);
Assert.Equal(user1.Organisation.Id, actual.OrganisationId);
Assert.Equal(data.LastName, actual.LastName);
}
}
public async Task UpdateAdviceService()
{
var options = TestHelper.GetDbContext("UpdateAdviceService");
//Given
var lkp1 = new AdviceServiceEntity {
Id = Guid.NewGuid(), Name = "1", DisplayOrder = 1
};
using (var context = new DataContext(options))
{
context.AdviceService.Add(lkp1);
context.SaveChanges();
}
var model = new AdviceService()
{
Id = lkp1.Id,
Name = "1 Updated",
DisplayOrder = 2
};
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var result = await service.UpdateAdviceService(model);
//Then
Assert.True(result.Success);
var actual = await context.AdviceService.FindAsync(model.Id);
Assert.Equal(model.Name, actual.Name);
Assert.Equal(model.DisplayOrder, actual.DisplayOrder);
}
}
public async Task GetVATRate()
{
var options = TestHelper.GetDbContext("GetVATRate");
//Given
var lkp1 = new VATRateEntity {
Id = Guid.NewGuid(), Rate = 14m, EndDate = new DateTime(2018, 4, 1).AddSeconds(-1)
};
var lkp2 = new VATRateEntity {
Id = Guid.NewGuid(), Rate = 15m, StartDate = new DateTime(2018, 4, 1)
};
using (var context = new DataContext(options))
{
//Jumbled order
context.VATRate.Add(lkp2);
context.VATRate.Add(lkp1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new DirectoryLookupService(context);
//When
var actual = await service.GetVATRate(new DateTime(2018, 4, 1));
//Then
Assert.Equal(15m, actual);
//When
actual = await service.GetVATRate(new DateTime(2018, 3, 31));
//Then
Assert.Equal(14m, actual);
}
}
public async Task ImportClient_Insert_WithCellphone()
{
var options = TestHelper.GetDbContext("ImportClient_Insert_WithCellphone");
var user1 = TestHelper.InsertUserDetailed(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var contactService = new ContactService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, contactService, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "8210035032082",
Cellphone = "082-572 8997"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var client = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == data.IdNumber);
var actual = await context.Contact.SingleOrDefaultAsync(c => c.ClientId == client.Id);
Assert.Equal("0825728997", actual.Value);
Assert.Equal(ContactType.CONTACT_TYPE_CELLPHONE, actual.ContactTypeId);
}
}
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 ImportClient_Update_WithContacts()
{
var options = TestHelper.GetDbContext("ImportClient_Update_WithContacts");
var user1 = TestHelper.InsertUserDetailed(options);
var mem = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL,
IdNumber = "8210035032082",
OrganisationId = user1.Organisation.Id
};
var contact1 = new ContactEntity
{
ClientId = mem.Id,
ContactTypeId = ContactType.CONTACT_TYPE_EMAIL,
Value = "*****@*****.**"
};
var contact2 = new ContactEntity
{
ClientId = mem.Id,
ContactTypeId = ContactType.CONTACT_TYPE_CELLPHONE,
Value = "0825728997"
};
using (var context = new DataContext(options))
{
context.Client.Add(mem);
context.Contact.Add(contact1);
context.Contact.Add(contact2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var contactService = new ContactService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, contactService, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = "8210035032082",
Email = contact1.Value,
Cellphone = "082 572-8997"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var client = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == data.IdNumber);
var contacts = await context.Contact.Where(c => c.ClientId == client.Id).ToListAsync();
Assert.Equal(2, contacts.Count);
var actual = contacts.First();
Assert.Equal(data.Email, actual.Value);
Assert.Equal(ContactType.CONTACT_TYPE_EMAIL, actual.ContactTypeId);
actual = contacts.Last();
Assert.Equal(contact2.Value, actual.Value);
Assert.Equal(ContactType.CONTACT_TYPE_CELLPHONE, actual.ContactTypeId);
}
}
public async Task ImportCommission_InsertCommission_NegitiveAmmount()
{
var options = TestHelper.GetDbContext("ImportCommission_InsertCommission_NegitiveAmmount");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(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>(),
};
using (var context = new DataContext(options))
{
context.CommissionType.Add(commissionType);
context.Policy.Add(policy1);
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 = "-100",
VAT = "-14"
};
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);
var actual = insertedCommissions.Single();
Assert.Equal(policy1.Id, actual.PolicyId);
Assert.Equal(commissionType.Id, actual.CommissionTypeId);
Assert.Equal(-100, actual.AmountIncludingVAT);
Assert.Equal(-14, actual.VAT);
Assert.Equal(statement.Id, actual.CommissionStatementId);
Assert.Equal(import1, actual.SourceData);
Assert.Equal(policy1.UserId, actual.UserId);
Assert.Null(actual.SplitGroupId);
}
}
public async Task ImportCommission_NoMapping_SetCommisionType()
{
var options = TestHelper.GetDbContext("ImportCommission_SetCommisionType");
var user1 = TestHelper.InsertUserDetailed(options);
var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var commissionType = new CommissionTypeEntity
{
Id = Guid.NewGuid(),
Code = "gap_cover"
};
using (var context = new DataContext(options))
{
context.CommissionType.Add(commissionType);
context.SaveChanges();
var auditService = new AuditServiceMock();
var statementService = new CommissionStatementService(context, null, auditService);
var lookupService = new DirectoryLookupService(context);
var commissionLookupService = new CommissionLookupService(context);
var commissionSplitService = new CommissionSplitService(context, auditService);
var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService);
var policyService = new PolicyService(context, auditService);
var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict);
var insertedErrors = new List <CommissionErrorEntity>();
bulkActions.Setup(c => c.BulkInsertCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionErrorEntity> >()))
.Callback((DataContext c, IList <CommissionErrorEntity> l) => insertedErrors = 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 = "123 456", // has spaces, should be removed
CommissionTypeCode = "gap_cover", //existing cover
AmountIncludingVAT = "100",
VAT = "14"
};
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.Empty(result.ValidationFailures);
//Check error record
var actual = insertedErrors.Single();
Assert.Null(actual.ClientId);
Assert.Null(actual.PolicyId);
Assert.Equal(commissionType.Id, actual.CommissionTypeId);
Assert.Equal(statement.Id, actual.CommissionStatementId);
import1.PolicyNumber = import1.PolicyNumber.TrimWhiteSpace();
Assert.Equal(import1, actual.Data);
}
}
public async Task ImportClient_Update()
{
var options = TestHelper.GetDbContext("ImportClient_Update");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var mem = new ClientEntity
{
Id = Guid.NewGuid(),
ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL,
FirstName = "FN 1",
LastName = "LN 1",
TaxNumber = "987654",
DateOfBirth = DateTime.Now,
IdNumber = "8210035032082",
OrganisationId = user1.Organisation.Id
};
using (var context = new DataContext(options))
{
context.Client.Add(mem);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, null, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = mem.IdNumber,
FirstName = "FN updated",
LastName = "LN updated",
TaxNumber = "456789",
DateOfBirth = DateTime.Now.AddDays(-20),
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Client.FirstOrDefaultAsync(m => m.IdNumber == data.IdNumber);
Assert.Equal(user1.Organisation.Id, actual.OrganisationId);
Assert.Equal(mem.ClientTypeId, actual.ClientTypeId); //Should not have changed
Assert.Equal(data.FirstName, actual.FirstName);
Assert.Equal(data.LastName, actual.LastName);
Assert.Equal(data.TaxNumber, actual.TaxNumber);
Assert.Equal(data.DateOfBirth, actual.DateOfBirth);
}
}
public async Task ImportClient_UpdatePolicy()
{
var options = TestHelper.GetDbContext("ImportClient_UpdatePolicy");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation, "8210035032082");
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var policyType1 = TestHelper.InsertPolicyType(options);
var policyType2 = TestHelper.InsertPolicyType(options);
var company = TestHelper.InsertCompany(options);
//Given
var policyEntity1 = new PolicyEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
ClientId = client1.Client.Id,
UserId = user2.User.Id,
PolicyTypeId = policyType2.Id,
Premium = 2000,
StartDate = DateTime.Now,
Number = "123465"
};
using (var context = new DataContext(options))
{
context.Policy.Add(policyEntity1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var clientService = new ClientService(context, auditService);
var policyService = new PolicyService(context, auditService);
var lookupService = new ClientLookupService(context);
var directoryLookupService = new DirectoryLookupService(context);
var service = new ClientImportService(context, clientService, policyService, null, lookupService, directoryLookupService);
//When
var data = new ImportClient()
{
IdNumber = client1.Client.IdNumber,
LastName = "LN",
PolicyNumber = policyEntity1.Number,
PolicyCompanyId = policyEntity1.CompanyId,
PolicyTypeCode = policyType1.Code,
PolicyPremium = 6000,
PolicyStartDate = DateTime.Now.AddDays(-100),
PolicyUserFullName = $"{user1.User.FirstName} {user1.User.LastName}"
};
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.ImportClient(scope, data);
//Then
Assert.True(result.Success);
var actual = await context.Policy.FirstOrDefaultAsync(m => m.Number == data.PolicyNumber);
Assert.Equal(data.PolicyCompanyId, actual.CompanyId);
Assert.Equal(user1.User.Id, actual.UserId);
Assert.Equal(data.PolicyPremium, actual.Premium);
Assert.Equal(data.PolicyStartDate, actual.StartDate);
Assert.Equal(policyType1.Id, actual.PolicyTypeId);
}
}
public async Task ImportCommissions_ScopeCheck()
{
var options = TestHelper.GetDbContext("ImportCommissions_ScopeCheck");
var user1 = TestHelper.InsertUserDetailed(options);
var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
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 statementService = new CommissionStatementService(context, null, auditService);
var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict);
bulkActions.Setup(c => c.BulkInsertCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionErrorEntity> >()))
.Returns(Task.CompletedTask);
var service = new CommissionImportService(
context,
bulkActions.Object,
statementService,
policyService,
lookupService,
commissionLookupService,
commissionSplitService,
commissionSplitRulePolicyService,
auditService);
//When
var import1 = new ImportCommission
{
PolicyNumber = "123456",
CommissionTypeCode = "gap_cover",
AmountIncludingVAT = "abc",
VAT = "zzz"
};
var imports = new List <ImportCommission>()
{
import1
};
var scope = TestHelper.GetScopeOptions(user2);
var result = await service.ImportCommissions(scope, statement.Id, imports);
//Then
Assert.Equal(0, result.ImportCount);
Assert.Equal(0, result.ErrorCount);
Assert.Empty(result.Results);
scope = TestHelper.GetScopeOptions(user1);
result = await service.ImportCommissions(scope, statement.Id, imports);
//Then
Assert.Equal(0, result.ImportCount);
Assert.Equal(1, result.ErrorCount);
Assert.Single(result.Results);
}
}
