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 queryOptions = new CommissionStatementTemplateQueryOptions(sortColumn, sortDirection, pageSize, pageNumber, filters);
var pagedItems = await CommissionStatementTemplateService.GetTemplates(queryOptions);
return(Ok(pagedItems));
}
public async Task Index()
{
var template = new CommissionStatementTemplate()
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1"
};
var pagedItems = new PagedItems <CommissionStatementTemplate>()
{
TotalItems = 1,
Items = new List <CommissionStatementTemplate>()
{
template
}
};
var service = new Mock <ICommissionStatementTemplateService>();
CommissionStatementTemplateQueryOptions queryOptions = null;
service.Setup(c => c.GetTemplates(It.IsAny <CommissionStatementTemplateQueryOptions>()))
.Callback((CommissionStatementTemplateQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionStatementTemplateController(service.Object);
var result = await controller.Index("Name", "desc", 15, 2, $"CompanyId={template.CompanyId}");
Assert.Equal("Name", queryOptions.SortOptions.Column);
Assert.Equal(SortDirection.Descending, queryOptions.SortOptions.Direction);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
Assert.Equal(template.CompanyId, queryOptions.CompanyId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <CommissionStatementTemplate> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task <PagedItems <CommissionStatementTemplate> > GetTemplates(CommissionStatementTemplateQueryOptions queryOptions)
{
var query = from template in _context.CommissionStatementTemplate
select new CommissionStatementTemplate()
{
Id = template.Id,
CompanyId = template.CompanyId,
Name = template.Name,
StartDate = template.StartDate,
EndDate = template.EndDate,
BrokerSpecific = template.BrokerSpecific,
};
//Apply filters ----------------------------------------------------------------------------------------
if (queryOptions.CompanyId.Any())
{
query = query.Where(c => queryOptions.CompanyId.Contains(c.CompanyId));
}
if (queryOptions.Date.HasValue)
{
query = query.Where(c => c.StartDate <= queryOptions.Date.Value.Date || c.StartDate == null);
query = query.Where(c => c.EndDate >= queryOptions.Date.Value.Date || c.EndDate == null);
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <CommissionStatementTemplate>();
//Get total items
pagedItems.TotalItems = await query.CountAsync();
//Ordering
query = query.OrderBy(queryOptions.SortOptions.Column, queryOptions.SortOptions.Direction);
//Paging
pagedItems.Items = await query.TakePage(queryOptions.PageOptions.Number, queryOptions.PageOptions.Size).ToListAsync();
return(pagedItems);
}
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 GetTemplates_DateFilter()
{
var options = TestHelper.GetDbContext("GetTemplates_DateFilter");
var now = DateTime.Now.Date;
//Given
//Start and End in scope
var temp1 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1",
StartDate = now.AddMonths(-1),
EndDate = now.AddMonths(1),
BrokerSpecific = true,
Config = new Config()
};
//Old start, old end, out of scope
var temp2 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 2",
StartDate = now.AddMonths(-12),
EndDate = now.AddMonths(-10),
BrokerSpecific = true,
Config = new Config()
};
//Old start, no end, in scope
var temp3 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 3",
StartDate = now.AddMonths(-12),
EndDate = null,
BrokerSpecific = true,
Config = new Config()
};
//Future start, no end, out of scope
var temp4 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 4",
StartDate = now.AddDays(1),
EndDate = null,
BrokerSpecific = true,
Config = new Config()
};
//Future end, no start, in scope
var temp5 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 5",
StartDate = null,
EndDate = now.AddMonths(1),
BrokerSpecific = true,
Config = new Config()
};
//Old end, no start, out of scope
var temp6 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 6",
StartDate = null,
EndDate = now.AddMonths(-5),
BrokerSpecific = true,
Config = new Config()
};
using (var context = new DataContext(options))
{
context.CommissionStatementTemplate.Add(temp1);
context.CommissionStatementTemplate.Add(temp2);
context.CommissionStatementTemplate.Add(temp3);
context.CommissionStatementTemplate.Add(temp4);
context.CommissionStatementTemplate.Add(temp5);
context.CommissionStatementTemplate.Add(temp6);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new CommissionStatementTemplateService(context, null, null);
//When
var queryOptions = new CommissionStatementTemplateQueryOptions("", "", 0, 0);
queryOptions.Date = now;
var result = await service.GetTemplates(queryOptions);
//Then
Assert.Equal(3, result.TotalItems);
var templates = result.Items.ToArray();
Assert.Equal(3, templates.Count());
var actual = templates[0];
Assert.Equal(temp1.Id, actual.Id);
actual = templates[1];
Assert.Equal(temp3.Id, actual.Id);
actual = templates[2];
Assert.Equal(temp5.Id, actual.Id);
}
}
public async Task GetTemplates()
{
var options = TestHelper.GetDbContext("GetTemplates");
//Given
var temp1 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1",
StartDate = DateTime.Now.AddDays(-1),
EndDate = DateTime.Now.AddDays(1),
BrokerSpecific = true,
Config = new Config()
};
var temp2 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 2",
BrokerSpecific = false,
StartDate = DateTime.Now.AddDays(-1),
EndDate = DateTime.Now.AddDays(1),
Config = new Config()
};
using (var context = new DataContext(options))
{
context.CommissionStatementTemplate.Add(temp1);
context.CommissionStatementTemplate.Add(temp2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var service = new CommissionStatementTemplateService(context, null, null);
//When
var queryOptions = new CommissionStatementTemplateQueryOptions("", "", 0, 0);
var actual = await service.GetTemplates(queryOptions);
//Then
Assert.Equal(2, actual.TotalItems);
var templates = actual.Items.ToArray();
Assert.Equal(2, templates.Count());
var actual1 = templates[0];
Assert.Equal(temp1.Id, actual1.Id);
Assert.Equal(temp1.Name, actual1.Name);
Assert.Equal(temp1.CompanyId, actual1.CompanyId);
Assert.Equal(temp1.StartDate, actual1.StartDate);
Assert.Equal(temp1.EndDate, actual1.EndDate);
Assert.Equal(temp1.BrokerSpecific, actual1.BrokerSpecific);
var actual2 = templates[1];
Assert.Equal(temp2.Id, actual2.Id);
Assert.Equal(temp2.Name, actual2.Name);
Assert.Equal(temp2.CompanyId, actual2.CompanyId);
Assert.Equal(temp2.StartDate, actual2.StartDate);
Assert.Equal(temp2.EndDate, actual2.EndDate);
Assert.Equal(temp2.BrokerSpecific, actual2.BrokerSpecific);
}
}
