public async Task Get()
{
var rule = new CommissionSplitRule()
{
Id = Guid.NewGuid(),
Name = Guid.NewGuid().ToString(),
UserId = Guid.NewGuid(),
IsDefault = true,
Split = new List <CommissionSplit>(),
};
var service = new Mock <ICommissionSplitService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetCommissionSplitRule(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == rule.Id.Value)))
.ReturnsAsync(rule);
var controller = new CommissionSplitRulesController(service.Object, authService.Object);
var result = await controller.Get(rule.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <CommissionSplitRule>(okResult.Value);
Assert.Same(rule, returnValue);
}
public async Task <Result> InsertCommissionSplitRule(ScopeOptions scope, CommissionSplitRule commissionSplitRule)
{
var validator = new CommissionSplitRuleValidator(_context, scope, true);
var result = validator.Validate(commissionSplitRule).GetResult();
if (!result.Success)
{
return(result);
}
if (commissionSplitRule.IsDefault)
{
await ClearDefaults(commissionSplitRule.UserId.Value);
}
var entity = MapModelToEntity(commissionSplitRule);
await _context.CommissionSplitRule.AddAsync(entity);
await _context.SaveChangesAsync();
commissionSplitRule.Id = entity.Id;
result.Tag = commissionSplitRule;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "CommissionSplitRule", entity.Id, commissionSplitRule);
return(result);
}
public async Task <Result> UpdateCommissionSplitRule(ScopeOptions scope, CommissionSplitRule commissionSplitRule)
{
var validator = new CommissionSplitRuleValidator(_context, scope, false);
var result = validator.Validate(commissionSplitRule).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetCommissionSplitRuleEntityQuery(scope).FirstOrDefaultAsync(c => c.Id == commissionSplitRule.Id);
if (entity == null)
{
return(new Result());
}
if (commissionSplitRule.IsDefault)
{
await ClearDefaults(commissionSplitRule.UserId.Value);
}
var commissionSplitRuleEntity = MapModelToEntity(commissionSplitRule, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "CommissionSplitRule", entity.Id, commissionSplitRule);
return(result);
}
public async Task <IActionResult> Insert([FromBody] CommissionSplitRule commissionSplitRule)
{
var scope = AuthenticationService.GetScope(User);
var result = await CommissionSplitService.InsertCommissionSplitRule(scope, commissionSplitRule);
if (!result.Success)
{
return(BadRequest(result.ValidationFailures));
}
return(Ok(result));
}
private CommissionSplitRuleEntity MapModelToEntity(CommissionSplitRule model, CommissionSplitRuleEntity entity = null)
{
if (entity == null)
{
entity = new CommissionSplitRuleEntity();
}
entity.UserId = model.UserId.Value;
entity.Name = model.Name;
entity.IsDefault = model.IsDefault;
entity.Split = model.Split;
return(entity);
}
public async Task InsertCommissionSplitRule()
{
var options = TestHelper.GetDbContext("InsertCommissionSplitRule");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options);
using (var context = new DataContext(options))
{
var csr1 = new CommissionSplitRule
{
UserId = user1.User.Id,
Name = "Com Split Rule 1",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var auditService = new AuditServiceMock();
var service = new CommissionSplitService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.InsertCommissionSplitRule(scope, csr1);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRule.FindAsync(((CommissionSplitRule)result.Tag).Id);
Assert.Equal(csr1.Id, actual.Id);
Assert.Equal(csr1.Name, actual.Name);
Assert.Equal(csr1.UserId, actual.UserId);
Assert.Equal(csr1.IsDefault, actual.IsDefault);
Assert.Equal(csr1.Split, actual.Split);
//Out of scope
scope = TestHelper.GetScopeOptions(user2, Scope.User);
result = await service.InsertCommissionSplitRule(scope, csr1);
Assert.False(result.Success);
Assert.Equal("'User' does not exist.", result.ValidationFailures.First().ErrorMessage);
}
}
public async Task Index()
{
var rule = new CommissionSplitRule()
{
Id = Guid.NewGuid(),
Name = Guid.NewGuid().ToString(),
UserId = Guid.NewGuid(),
IsDefault = true,
Split = new List <CommissionSplit>(),
};
var pagedItems = new PagedItems <CommissionSplitRule>()
{
TotalItems = 1,
Items = new List <CommissionSplitRule>()
{
rule
}
};
var service = new Mock <ICommissionSplitService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
CommissionSplitRuleQueryOptions queryOptions = null;
service.Setup(c => c.GetCommissionSplitRules(It.IsAny <CommissionSplitRuleQueryOptions>()))
.Callback((CommissionSplitRuleQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new CommissionSplitRulesController(service.Object, authService.Object);
var result = await controller.Index("Name", "desc", 15, 2, $"UserId={rule.UserId}");
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
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(rule.UserId, queryOptions.UserId.Single());
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <CommissionSplitRule> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public async Task Update()
{
var rule = new CommissionSplitRule()
{
Id = Guid.NewGuid(),
Name = Guid.NewGuid().ToString(),
UserId = Guid.NewGuid(),
IsDefault = true,
Split = new List <CommissionSplit>(),
};
var service = new Mock <ICommissionSplitService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
CommissionSplitRule updated = null;
service.Setup(c => c.UpdateCommissionSplitRule(It.IsAny <ScopeOptions>(), It.IsAny <CommissionSplitRule>()))
.Callback((ScopeOptions o, CommissionSplitRule i) =>
{
updated = i;
options = o;
})
.ReturnsAsync(result);
var controller = new CommissionSplitRulesController(service.Object, authService.Object);
var actual = await controller.Update(rule.Id.Value, rule);
Assert.Same(rule, 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 UpdateCommissionSplitRule()
{
var options = TestHelper.GetDbContext("UpdateCommissionSplitRule");
var user1 = TestHelper.InsertUserDetailed(options);
var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation);
var user3 = TestHelper.InsertUserDetailed(options);
var csr1 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user1.User.Id,
Name = "Com Split Rule 1",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 100
}
}
};
var csr2 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user2.User.Id,
Name = "Com Split Rule 2",
IsDefault = false,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 100
}
}
};
var csr3 = new CommissionSplitRuleEntity
{
Id = Guid.NewGuid(),
UserId = user3.User.Id,
Name = "Com Split Rule 3",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user3.User.Id,
Percentage = 100
}
}
};
using (var context = new DataContext(options))
{
context.CommissionSplitRule.Add(csr2);
context.CommissionSplitRule.Add(csr1);
context.CommissionSplitRule.Add(csr3);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var csr2Updated = new CommissionSplitRule
{
Id = csr2.Id,
UserId = user1.User.Id,
Name = "Com Split Rule 2 updated",
IsDefault = true,
Split = new List <CommissionSplit>()
{
new CommissionSplit()
{
UserId = user1.User.Id,
Percentage = 50
},
new CommissionSplit()
{
UserId = user2.User.Id,
Percentage = 50
}
}
};
var auditService = new AuditServiceMock();
var service = new CommissionSplitService(context, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateCommissionSplitRule(scope, csr2Updated);
//Then
Assert.True(result.Success);
var actual = await context.CommissionSplitRule.FindAsync(csr2Updated.Id);
Assert.Equal(csr2Updated.Id, actual.Id);
Assert.Equal(csr2Updated.Name, actual.Name);
Assert.Equal(csr2Updated.UserId, actual.UserId);
Assert.Equal(csr2Updated.IsDefault, actual.IsDefault);
Assert.Equal(csr2Updated.Split, actual.Split);
//Check is default clear from csr1
actual = await context.CommissionSplitRule.FindAsync(csr1.Id);
Assert.False(actual.IsDefault);
//Out of scope
scope = TestHelper.GetScopeOptions(user3, Scope.User);
result = await service.UpdateCommissionSplitRule(scope, csr2Updated);
Assert.False(result.Success);
Assert.Equal("'User' does not exist.", result.ValidationFailures.First().ErrorMessage);
}
}
