public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest request,
ILogger log)
{
Guid organisationId = Guid.Parse(request.Query["organisationId"]);
Guid commissionStatementId = Guid.Parse(request.Query["commissionStatementId"]);
Guid commissionStatementTemplateId = Guid.Parse(request.Query["commissionStatementTemplateId"]);
var scope = new ScopeOptions(organisationId, Guid.Empty, Guid.Empty, Scope.Organisation);
var statement = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId);
if (statement == null)
{
return(new NotFoundObjectResult(commissionStatementId));
}
var path = new CommissionStatementPath(scope.OrganisationId, commissionStatementId);
var files = await FileStorageService.GetFilesAsync(path);
if (!files.Any())
{
return(Utils.GetBadRequestObject("Reimport failed as there are no existing statement files.", commissionStatementId.ToString()));
}
var queryOptions = new CommissionStatementTemplateQueryOptions("", "", 0, 0);
queryOptions.CompanyId.Add(statement.CompanyId.Value);
queryOptions.Date = statement.Date;
var templates = (await CommissionStatementTemplateService.GetTemplates(queryOptions)).Items;
if (!templates.Any(t => t.Id == commissionStatementTemplateId))
{
return(Utils.GetBadRequestObject("Reimport failed as the commissionStatementTemplateId is not valid.", commissionStatementTemplateId.ToString()));
}
var template = await CommissionStatementTemplateService.GetTemplate(commissionStatementTemplateId);
await CommissionStatementService.DeleteCommissions(scope, commissionStatementId);
var result = new ImportResult();
foreach (var fileInfo in files)
{
using (var stream = new MemoryStream())
{
await FileStorageService.GetFile(fileInfo.Url, stream);
var vatRate = await DirectoryLookupService.GetVATRate(statement.Date ?? DateTime.Now);
var reader = new CommissionImportReader(template.Config, vatRate);
var items = reader.Read(stream);
result = await CommissionImportService.ImportCommissions(scope, commissionStatementId, items);
}
}
return(new OkObjectResult(result));
}
public async Task <IActionResult> Index(string sortColumn, string sortDirection, int pageSize = 0, int pageNumber = 0, string filters = null)
{
var scope = AuthenticationService.GetScope(User);
var queryOptions = new CommissionStatementQueryOptions(scope, sortColumn, sortDirection, pageSize, pageNumber, filters);
var pagedItems = await CommissionStatementService.GetCommissionStatements(queryOptions);
return(Ok(pagedItems));
}
public async Task <IActionResult> Insert([FromBody] CommissionStatementEdit commissionStatement)
{
var scope = AuthenticationService.GetScope(User);
var result = await CommissionStatementService.InsertCommissionStatement(scope, commissionStatement);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task <IActionResult> Get(Guid commissionStatementId)
{
var scope = AuthenticationService.GetScope(User);
var model = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId);
if (model == null)
{
return(NotFound());
}
return(Ok(model));
}
private async Task SendZeroEntriesEmail(
ScopeOptions scope,
Guid commissionStatementId,
CommissionStatementTemplateEdit template,
Attachment attachment)
{
var organisation = await OrganisationService.GetOrganisation(scope, scope.OrganisationId);
var user = await UserService.GetUser(scope, scope.UserId);
var statement = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId);
var company = await DirectoryLookupService.GetCompany(statement.CompanyId.Value);
await EmailService.SendImportCommissionZeroEntriesEmail(Utils.GetEnvironment(), organisation, user, company, statement, template, attachment);
}
public async Task <IActionResult> DeleteCommissions(Guid commissionStatementId)
{
var scope = AuthenticationService.GetScope(User);
await CommissionStatementService.DeleteCommissions(scope, commissionStatementId);
var path = new CommissionStatementDirectoryPath(scope.OrganisationId, commissionStatementId);
var files = await FileStorageService.GetFileInfoListAsync(path);
foreach (var file in files)
{
await FileStorageService.SoftDeleteFile(file.Url);
}
return(Ok(new Result(true)));
}
public async Task DeleteCommissions()
{
var options = TestHelper.GetDbContext("UpdateCommissionStatement");
var user1 = TestHelper.InsertUserDetailed(options);
var statement1 = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
var statement2 = TestHelper.InsertCommissionStatement(options, user2.Organisation);
using (var context = new DataContext(options))
{
var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict);
var actualCommissionStatementId1 = Guid.Empty;
bulkActions.Setup(c => c.BatchDeleteCommissionsAsync(It.IsAny <DataContext>(), It.IsAny <Guid>()))
.Callback((DataContext c, Guid g1) => actualCommissionStatementId1 = g1)
.Returns(Task.CompletedTask);
var actualCommissionStatementId2 = Guid.Empty;
bulkActions.Setup(c => c.BatchDeleteCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <Guid>()))
.Callback((DataContext c, Guid g1) => actualCommissionStatementId2 = g1)
.Returns(Task.CompletedTask);
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, bulkActions.Object, auditService);
//When
var scopeOptions = TestHelper.GetScopeOptions(user1);
await service.DeleteCommissions(scopeOptions, statement1.Id);
//Then
Assert.Equal(statement1.Id, actualCommissionStatementId1);
Assert.Equal(statement1.Id, actualCommissionStatementId2);
//Reset
actualCommissionStatementId1 = Guid.Empty;
actualCommissionStatementId2 = Guid.Empty;
// //Out of scope
await service.DeleteCommissions(scopeOptions, statement2.Id);
Assert.Equal(Guid.Empty, actualCommissionStatementId1);
Assert.Equal(Guid.Empty, actualCommissionStatementId2);
}
}
public async Task InsertCommissionStatement()
{
var options = TestHelper.GetDbContext("InsertCommissionStatement");
var user1 = TestHelper.InsertUserDetailed(options);
//Given
var cs1 = new CommissionStatementEdit
{
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 100,
VAT = 10,
Date = DateTime.Now,
Processed = true,
Notes = "note 1"
};
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, null, auditService);
//When
var scopeOptions = TestHelper.GetScopeOptions(user1);
var result = await service.InsertCommissionStatement(scopeOptions, cs1);
//Then
Assert.True(result.Success);
var actual = await context.CommissionStatement.FindAsync(((CommissionStatementEdit)result.Tag).Id);
Assert.Equal(cs1.CompanyId, actual.CompanyId);
Assert.Equal(cs1.Date.Value.Date, actual.Date);
Assert.Equal(cs1.AmountIncludingVAT, actual.AmountIncludingVAT);
Assert.Equal(cs1.VAT, actual.VAT);
Assert.Equal(user1.Organisation.Id, user1.Organisation.Id);
Assert.Equal(cs1.Processed, actual.Processed);
Assert.Equal(cs1.Notes, actual.Notes);
}
}
public async Task GetCommissionStatements()
{
var options = TestHelper.GetDbContext("GetCommissionStatements");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options);
var company = TestHelper.InsertCompany(options);
var cs1 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
AmountIncludingVAT = 111,
VAT = 11,
Date = DateTime.Now,
Processed = true,
OrganisationId = user1.Organisation.Id,
Notes = "note 1"
};
var cs2 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
AmountIncludingVAT = 222,
VAT = 22,
Date = DateTime.Now.AddDays(-1),
Processed = false,
OrganisationId = user1.Organisation.Id,
Notes = "note 2"
};
var cs3 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
AmountIncludingVAT = 333,
VAT = 33,
Date = DateTime.Now.AddDays(-2),
Processed = false,
OrganisationId = user1.Organisation.Id,
Notes = "note 3"
};
var cs4 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
AmountIncludingVAT = 444,
VAT = 44,
Date = DateTime.Now.AddDays(-2),
Processed = false,
OrganisationId = user2.Organisation.Id,
Notes = "note 4"
};
var commission1a = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 50,
VAT = 5,
CommissionStatementId = cs1.Id,
UserId = user1.User.Id
};
var commission1b = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 50,
VAT = 5,
CommissionStatementId = cs1.Id,
UserId = user1.User.Id,
};
var commission2 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 200,
VAT = 20,
CommissionStatementId = cs2.Id,
UserId = user1.User.Id,
};
var commission3 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 300,
VAT = 30,
CommissionStatementId = cs3.Id,
UserId = user1.User.Id,
};
var commission4 = new CommissionEntity
{
Id = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
AmountIncludingVAT = 40,
VAT = 400,
CommissionStatementId = cs4.Id,
UserId = user2.User.Id,
};
using (var context = new DataContext(options))
{
context.CommissionStatement.Add(cs1);
context.CommissionStatement.Add(cs2);
context.CommissionStatement.Add(cs3);
context.CommissionStatement.Add(cs4);
context.Commission.Add(commission1a);
context.Commission.Add(commission1b);
context.Commission.Add(commission2);
context.Commission.Add(commission3);
context.Commission.Add(commission4);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var queryOptions = new CommissionStatementQueryOptions(scope, "", "", 0, 0);
var statements = await service.GetCommissionStatements(queryOptions);
//Then
Assert.Equal(3, statements.TotalItems);
Assert.Equal(3, statements.Items.Count());
Assert.Equal(600, statements.SumAmountIncludingVAT);
Assert.Equal(60, statements.SumVAT);
var items = statements.Items.ToList();
var actual = items[0];
Assert.Equal(cs1.Id, actual.Id);
Assert.Equal(cs1.CompanyId, actual.CompanyId);
Assert.Equal(cs1.Date, actual.Date);
Assert.Equal(cs1.AmountIncludingVAT, actual.AmountIncludingVAT);
Assert.Equal(cs1.VAT, actual.VAT);
Assert.Equal(cs1.Processed, actual.Processed);
Assert.Equal(cs1.Notes, actual.Notes);
Assert.Equal(cs1.OrganisationId, user1.Organisation.Id);
Assert.Equal(100, actual.ActualAmountIncludingVAT);
Assert.Equal(10, actual.ActualVAT);
Assert.Equal(2, actual.CommissionCount);
actual = items[1];
Assert.Equal(cs2.Id, actual.Id);
actual = items[2];
Assert.Equal(cs3.Id, actual.Id);
//Check scope
scope = TestHelper.GetScopeOptions(user2);
queryOptions = new CommissionStatementQueryOptions(scope, "", "", 0, 0);
statements = await service.GetCommissionStatements(queryOptions);
Assert.Single(statements.Items);
actual = statements.Items.First();
Assert.Equal(cs4.Id, actual.Id);
}
}
public async Task <IActionResult> Import(Guid commissionStatementId, [FromQuery] Guid commissionStatementTemplateId, [FromQuery] Guid?userId)
{
var scope = AuthenticationService.GetScope(User);
var file = Request.Form.Files.FirstOrDefault();
if (file == null)
{
return(BadRequest());
}
var statement = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId);
var template = await CommissionStatementTemplateService.GetTemplate(commissionStatementTemplateId);
string brokerFullName = null;
if (template.BrokerSpecific)
{
if (!userId.HasValue)
{
return(this.BadRequestMessage("UserId required for broker specific templates."));
}
var user = await UserService.GetUser(scope, userId.Value);
if (user == null)
{
return(this.BadRequestMessage("Invalid UserId."));
}
brokerFullName = $"{user.FirstName} {user.LastName}";
}
var config = template.Config;
var result = new ImportResult();
using (var stream = file.OpenReadStream())
{
var vatRate = await DirectoryLookupService.GetVATRate(statement.Date ?? DateTime.Now);
var reader = new CommissionImportReader(config, vatRate, brokerFullName);
var items = reader.Read(stream);
result = await CommissionImportService.ImportCommissions(scope, commissionStatementId, items);
}
if (result.UnknownCommissionTypeValues.Any())
{
using (var stream = file.OpenReadStream())
{
var attachment = GetEmailAttachment(file, stream);
await SendUnkownCommissionTypesEmail(result, scope, commissionStatementId, template, attachment);
}
}
if (!result.Results.Any(r => r.Success))
{
using (var stream = file.OpenReadStream())
{
var attachment = GetEmailAttachment(file, stream);
await SendZeroEntriesEmail(scope, commissionStatementId, template, attachment);
}
}
if (result.Results.Any())
{
using (var stream = file.OpenReadStream())
{
var path = new CommissionStatementFilePath(scope.OrganisationId, commissionStatementId, file.FileName);
await FileStorageService.AddFileAsync(path, stream);
}
}
return(Ok(result));
}
public async Task <IActionResult> Reimport(Guid commissionStatementId, [FromQuery] Guid commissionStatementTemplateId, [FromQuery] Guid?userId)
{
var scope = AuthenticationService.GetScope(User);
var statement = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId);
if (statement == null)
{
return(NotFound());
}
var path = new CommissionStatementDirectoryPath(scope.OrganisationId, commissionStatementId);
var fileInfoList = await FileStorageService.GetFileInfoListAsync(path);
if (!fileInfoList.Any())
{
return(this.BadRequestMessage("Reimport failed as there are no existing statement files."));
}
var queryOptions = new CommissionStatementTemplateQueryOptions("", "", 0, 0);
queryOptions.CompanyId.Add(statement.CompanyId.Value);
queryOptions.Date = statement.Date;
var templates = (await CommissionStatementTemplateService.GetTemplates(queryOptions)).Items;
if (!templates.Any(t => t.Id == commissionStatementTemplateId))
{
return(this.BadRequestMessage("Reimport failed as the commissionStatementTemplateId is not valid."));
}
var template = await CommissionStatementTemplateService.GetTemplate(commissionStatementTemplateId);
string brokerFullName = null;
if (template.BrokerSpecific)
{
if (!userId.HasValue)
{
return(this.BadRequestMessage("UserId required for broker specific templates."));
}
var user = await UserService.GetUser(scope, userId.Value);
if (user == null)
{
return(this.BadRequestMessage("Invalid UserId."));
}
brokerFullName = $"{user.FirstName} {user.LastName}";
}
await CommissionStatementService.DeleteCommissions(scope, commissionStatementId);
var result = new ImportResult();
foreach (var fileInfo in fileInfoList)
{
using (var stream = new MemoryStream())
{
await FileStorageService.GetFile(fileInfo.Url, stream);
var vatRate = await DirectoryLookupService.GetVATRate(statement.Date ?? DateTime.Now);
var reader = new CommissionImportReader(template.Config, vatRate, brokerFullName);
var items = reader.Read(stream);
result = await CommissionImportService.ImportCommissions(scope, commissionStatementId, items);
if (result.UnknownCommissionTypeValues.Any())
{
stream.Position = 0;
using (var copy = new MemoryStream())
{
await stream.CopyToAsync(copy);
copy.Position = 0;
var attachment = GetEmailAttachmentFromCloud(fileInfo, copy);
await SendUnkownCommissionTypesEmail(result, scope, commissionStatementId, template, attachment);
}
}
if (!result.Results.Any(r => r.Success))
{
stream.Position = 0;
using (var copy = new MemoryStream())
{
await stream.CopyToAsync(copy);
copy.Position = 0;
var attachment = GetEmailAttachmentFromCloud(fileInfo, copy);
await SendZeroEntriesEmail(scope, commissionStatementId, template, attachment);
}
}
}
}
return(Ok(result));
}
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 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 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 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);
}
}
public async Task GetCommissionStatements_DateFilter()
{
var options = TestHelper.GetDbContext("GetCommissionStatements_DateFilter");
var user1 = TestHelper.InsertUserDetailed(options);
var company = TestHelper.InsertCompany(options);
var cs1 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
Date = new DateTime(2000, 1, 1),
OrganisationId = user1.Organisation.Id
};
var cs2 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
Date = new DateTime(2000, 1, 20),
OrganisationId = user1.Organisation.Id
};
var cs3 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
Date = new DateTime(2000, 1, 31),
OrganisationId = user1.Organisation.Id
};
var cs4 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
Date = new DateTime(2000, 2, 1),
OrganisationId = user1.Organisation.Id
};
using (var context = new DataContext(options))
{
context.CommissionStatement.Add(cs1);
context.CommissionStatement.Add(cs2);
context.CommissionStatement.Add(cs3);
context.CommissionStatement.Add(cs4);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var filters = "startDate=1999-12-01;endDate=1999-12-31";
var queryOptions = new CommissionStatementQueryOptions(scope, "", "", 0, 0, filters);
var statements = await service.GetCommissionStatements(queryOptions);
Assert.Equal(0, statements.TotalItems);
Assert.Empty(statements.Items);
filters = "startDate=2000-01-01;endDate=2000-01-21";
queryOptions = new CommissionStatementQueryOptions(scope, "Date", "desc", 0, 0, filters);
statements = await service.GetCommissionStatements(queryOptions);
//Then
Assert.Equal(2, statements.TotalItems);
var items = statements.Items.ToList();
Assert.Equal(cs2.Id, items[0].Id);
Assert.Equal(cs1.Id, items[1].Id);
filters = "startDate=2000-01-01;endDate=2000-01-31";
queryOptions = new CommissionStatementQueryOptions(scope, "Date", "desc", 0, 0, filters);
statements = await service.GetCommissionStatements(queryOptions);
//Then
Assert.Equal(3, statements.TotalItems);
Assert.Equal(3, statements.Items.Count());
items = statements.Items.ToList();
Assert.Equal(cs3.Id, items[0].Id);
Assert.Equal(cs2.Id, items[1].Id);
Assert.Equal(cs1.Id, items[2].Id);
}
}
public async Task GetCommissionStatement()
{
var options = TestHelper.GetDbContext("GetCommissionStatement");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options);
var cs1 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 100,
VAT = 10,
Date = DateTime.Now,
Processed = true,
OrganisationId = user1.Organisation.Id,
Notes = "note 1"
};
var cs2 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 200,
VAT = 20,
Date = DateTime.Now.AddDays(-1),
Processed = false,
OrganisationId = user1.Organisation.Id,
Notes = "note 2"
};
using (var context = new DataContext(options))
{
context.CommissionStatement.Add(cs1);
context.CommissionStatement.Add(cs2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var actual = await service.GetCommissionStatement(scope, cs2.Id);
//Then
Assert.Equal(cs2.Id, actual.Id);
Assert.Equal(cs2.CompanyId, actual.CompanyId);
Assert.Equal(cs2.Date, actual.Date);
Assert.Equal(cs2.AmountIncludingVAT, actual.AmountIncludingVAT);
Assert.Equal(cs2.VAT, actual.VAT);
Assert.Equal(cs2.OrganisationId, user1.Organisation.Id);
Assert.Equal(cs2.Processed, actual.Processed);
Assert.Equal(cs2.Notes, actual.Notes);
//Check scope
scope = TestHelper.GetScopeOptions(user2);
actual = await service.GetCommissionStatement(scope, cs2.Id);
Assert.Null(actual);
}
}
public async Task UpdateCommissionStatement()
{
var options = TestHelper.GetDbContext("UpdateCommissionStatement");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options);
var cs1 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 100,
VAT = 10,
Date = DateTime.Now,
Processed = true,
OrganisationId = user1.Organisation.Id,
Notes = "note 1"
};
var cs2 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 200,
VAT = 20,
Date = DateTime.Now.AddDays(-1),
Processed = false,
OrganisationId = user1.Organisation.Id,
Notes = "note 2"
};
using (var context = new DataContext(options))
{
context.CommissionStatement.Add(cs1);
context.CommissionStatement.Add(cs2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionStatementService(context, null, auditService);
var model = new CommissionStatementEdit
{
Id = cs2.Id,
CompanyId = Guid.NewGuid(),
AmountIncludingVAT = 300,
VAT = 30,
Date = DateTime.Now.AddDays(-10),
Processed = true,
Notes = "note 2 updated"
};
//When
var scopeOptions = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateCommissionStatement(scopeOptions, model);
//Then
Assert.True(result.Success);
var actual = await context.CommissionStatement.FindAsync(model.Id);
Assert.Equal(model.CompanyId, actual.CompanyId);
Assert.Equal(model.Date.Value.Date, actual.Date);
Assert.Equal(model.AmountIncludingVAT, actual.AmountIncludingVAT);
Assert.Equal(model.VAT, actual.VAT);
Assert.Equal(user1.Organisation.Id, user1.Organisation.Id);
Assert.Equal(model.Processed, actual.Processed);
Assert.Equal(model.Notes, actual.Notes);
//Out of scope
scopeOptions = TestHelper.GetScopeOptions(user2, Scope.User);
result = await service.UpdateCommissionStatement(scopeOptions, model);
Assert.False(result.Success);
}
}
