public async Task <Result> UpdateCommissionStatement(ScopeOptions scope, CommissionStatementEdit commissionStatement)
{
var validator = new CommissionStatementValidator(_context, scope, false);
var result = validator.Validate(commissionStatement).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetCommissionStatementEntityQuery(scope).FirstOrDefaultAsync(c => c.Id == commissionStatement.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(commissionStatement, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "CommissionStatement", entity.Id, commissionStatement);
return(result);
}
public async Task Get()
{
var statement = new CommissionStatementEdit()
{
Id = Guid.NewGuid(),
AmountIncludingVAT = 350000,
VAT = 25000,
CompanyId = Guid.NewGuid(),
Date = DateTime.Now,
Processed = true
};
var service = new Mock <ICommissionStatementService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetCommissionStatement(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == statement.Id.Value)))
.ReturnsAsync(statement);
var controller = new CommissionStatementsController(service.Object, authService.Object, null);
var result = await controller.Get(statement.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <CommissionStatementEdit>(okResult.Value);
Assert.Same(statement, returnValue);
}
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 <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 CommissionStatementEntity MapModelToEntity(CommissionStatementEdit model, CommissionStatementEntity entity = null)
{
if (entity == null)
{
entity = new CommissionStatementEntity();
}
entity.CompanyId = model.CompanyId.Value;
entity.AmountIncludingVAT = model.AmountIncludingVAT.Value;
entity.VAT = model.VAT.Value;
entity.Date = model.Date.Value.Date;
entity.Processed = model.Processed.Value;
entity.Notes = model.Notes;
return(entity);
}
public async Task Update()
{
var statement = new CommissionStatementEdit()
{
Id = Guid.NewGuid(),
AmountIncludingVAT = 350000,
VAT = 25000,
CompanyId = Guid.NewGuid(),
Date = DateTime.Now,
Processed = true
};
var service = new Mock <ICommissionStatementService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
CommissionStatementEdit updated = null;
service.Setup(c => c.UpdateCommissionStatement(It.IsAny <ScopeOptions>(), It.IsAny <CommissionStatementEdit>()))
.Callback((ScopeOptions o, CommissionStatementEdit u) =>
{
updated = u;
options = o;
})
.ReturnsAsync(result);
var controller = new CommissionStatementsController(service.Object, authService.Object, null);
var actual = await controller.Update(statement.Id.Value, statement);
Assert.Same(statement, updated);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
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 <Result> InsertCommissionStatement(ScopeOptions scope, CommissionStatementEdit commissionStatement)
{
var validator = new CommissionStatementValidator(_context, scope, true);
var result = validator.Validate(commissionStatement).GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(commissionStatement);
entity.OrganisationId = scope.OrganisationId;
await _context.CommissionStatement.AddAsync(entity);
await _context.SaveChangesAsync();
commissionStatement.Id = entity.Id;
result.Tag = commissionStatement;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "CommissionStatement", entity.Id, commissionStatement);
return(result);
}
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);
}
}
