public async Task UpdateTemplate()
{
var options = TestHelper.GetDbContext("UpdateTemplate");
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()
};
using (var context = new DataContext(options))
{
context.CommissionStatementTemplate.Add(temp2);
context.CommissionStatementTemplate.Add(temp1);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var template = new CommissionStatementTemplateEdit
{
Id = temp1.Id,
CompanyId = Guid.NewGuid(),
Name = "Template 1 updated",
StartDate = DateTime.Now.AddDays(-2),
EndDate = DateTime.Now.AddDays(2),
BrokerSpecific = false,
Config = GetValidConfig()
};
var service = new CommissionStatementTemplateService(context, null, null);
//When
var result = await service.UpdateTemplate(template);
//Then
Assert.True(result.Success);
var actual = await context.CommissionStatementTemplate.FindAsync(temp1.Id);
Assert.Equal(template.Name, actual.Name);
Assert.Equal(template.CompanyId, actual.CompanyId);
Assert.Equal(template.Config, actual.Config);
Assert.Equal(template.StartDate.Value.Date, actual.StartDate);
Assert.Equal(template.EndDate.Value.Date, actual.EndDate);
Assert.Equal(template.BrokerSpecific, actual.BrokerSpecific);
}
}
public async Task <IActionResult> Insert([FromBody] CommissionStatementTemplateEdit template)
{
var result = await CommissionStatementTemplateService.InsertTemplate(template);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
public async Task <Result> SendImportCommissionUnknownCommissionTypesEmail(
string environment,
OrganisationEdit organisation,
UserEdit user,
Company company,
CommissionStatementEdit statement,
CommissionStatementTemplateEdit template,
List <string> unknownCommissionTypes,
Attachment attachment)
{
var result = new Result();
var response = await _email
.To(_options.Emails.CommissionImportAlerts.To)
.Subject("One Advisor - ALERT: Unknown Commission Types Found")
.UsingTemplate(ImportUnknownCommissionTypes.Template,
new
{
Environment = environment,
OrganisationName = organisation.Name,
UserFirstName = user.FirstName,
UserLastName = user.LastName,
Username = user.UserName,
UserEmail = user.Email,
CompanyName = company.Name,
StatementDate = statement.Date.Value.ToLongDateString(),
StatementStatus = statement.Processed.Value ? "Processed" : "Processing",
StatementTemplateName = template.Name,
CommissionTypes = unknownCommissionTypes
}
)
.Attach(new FluentEmail.Core.Models.Attachment()
{
Filename = attachment.FileName,
ContentType = attachment.ContentType,
Data = attachment.Data
})
.SendAsync();
result.Success = response.Successful;
if (!result.Success)
{
result.Errors = response.ErrorMessages;
return(result);
}
return(result);
}
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);
}
private CommissionStatementTemplateEntity MapModelToEntity(CommissionStatementTemplateEdit model, CommissionStatementTemplateEntity entity = null)
{
if (entity == null)
{
entity = new CommissionStatementTemplateEntity();
}
entity.Name = model.Name;
entity.CompanyId = model.CompanyId.Value;
entity.Config = model.Config;
entity.StartDate = model.StartDate.HasValue ? (DateTime?)model.StartDate.Value.Date : null;
entity.EndDate = model.EndDate.HasValue ? (DateTime?)model.EndDate.Value.Date : null;
entity.BrokerSpecific = model.BrokerSpecific;
return(entity);
}
public async Task <Result> InsertTemplate(CommissionStatementTemplateEdit template)
{
var validator = new CommissionStatementTemplateValidator(true);
var result = validator.Validate(template).GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(template);
await _context.CommissionStatementTemplate.AddAsync(entity);
await _context.SaveChangesAsync();
template.Id = entity.Id;
result.Tag = template;
return(result);
}
public async Task <Result> UpdateTemplate(CommissionStatementTemplateEdit template)
{
var validator = new CommissionStatementTemplateValidator(false);
var result = validator.Validate(template).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await _context.CommissionStatementTemplate.FirstOrDefaultAsync(b => b.Id == template.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(template, entity);
await _context.SaveChangesAsync();
return(result);
}
public async Task Update()
{
var template = new CommissionStatementTemplateEdit()
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1",
Config = new Config()
};
var service = new Mock <ICommissionStatementTemplateService>();
var result = new Result()
{
Success = true
};
CommissionStatementTemplateEdit updated = null;
service.Setup(c => c.UpdateTemplate(It.IsAny <CommissionStatementTemplateEdit>()))
.Callback((CommissionStatementTemplateEdit u) =>
{
updated = u;
})
.ReturnsAsync(result);
var controller = new CommissionStatementTemplateController(service.Object);
var actual = await controller.Update(template.Id.Value, false, template);
Assert.Same(template, updated);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async Task Get()
{
var template = new CommissionStatementTemplateEdit()
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
Name = "Template 1",
Config = new Config()
};
var service = new Mock <ICommissionStatementTemplateService>();
service.Setup(c => c.GetTemplate(It.Is <Guid>(m => m == template.Id.Value)))
.ReturnsAsync(template);
var controller = new CommissionStatementTemplateController(service.Object);
var result = await controller.Get(template.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <CommissionStatementTemplateEdit>(okResult.Value);
Assert.Same(template, returnValue);
}
public async Task <IActionResult> Update(Guid templateId, [FromQuery] bool updateUnknownCommissionTypes, [FromBody] CommissionStatementTemplateEdit template)
{
template.Id = templateId;
var result = await CommissionStatementTemplateService.UpdateTemplate(template);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
if (updateUnknownCommissionTypes)
{
await CommissionStatementTemplateService.UpdateUnknownCommissionTypes(template.Id.Value);
}
return(Ok(result));
}