public async Task <Guid> Create(Sheet sheetRequest)
{
var sheet = SheetAggregate.CreateFromSheetDto(sheetRequest);
await _sheetAggregateRepo.Add(sheet);
return(sheet.Id);
}
public async Task Approve(Guid sheetId)
{
var sheet = await _sheetAggregateRepo.GetItem(sheetId);
SheetAggregate.ApproveSheet(sheetId, sheet);
await _sheetAggregateRepo.Update(sheetId, sheet);
}
public async Task <Guid> Create(SheetCreateRequest request)
{
var sheet = SheetAggregate.CreateFromRequest(request);
await _repo.Add(sheet);
return(sheet.Id);
}
public void IncludeUpdateTest()
{
var sheetBuilder = new SheetAggregateBuilder();
var sheetAggregate = sheetBuilder.CreateRandomSheet();
var sheet = SheetAggregate.Update(sheetAggregate.Id, sheetAggregate);
sheetAggregate.Should().BeEquivalentTo(sheet);
}
public void ApproveSheetTest()
{
var builder = new SheetAggregateBuilder();
var sheet = builder.CreateRandomSheet();
sheet = SheetAggregate.ApproveSheet(sheet.Id, sheet);
sheet.IsApproved.Should().BeTrue();
sheet.ApprovedDate.Should().BeExactly(TimeSpan.FromSeconds(DateTimeOffset.Now.ToUnixTimeSeconds()));
}
public void SheetAggregate_ShouldBeDeleted()
{
//Arrange
var request = AggregatesRequestBuilder.CreateRandomSheetCreateRequest();
var sheet = SheetAggregate.CreateFromRequest(request);
//Act
sheet.MarkAsDeleted();
//Assert
sheet.IsDeleted.Should().BeTrue();
}
public void CreateTest()
{
var builder = new SheetAggregateBuilder();
var sheet = SheetAggregate.Create(
builder.amountForRandomSheets,
builder.SheetContractId,
DateTime.Now,
builder.SheetEmployeeId,
builder.SheetServiceId);
sheet.Should().As <SheetAggregate>();
}
public void SheetAggregate_ShouldBeApproved()
{
//Arrange
var request = AggregatesRequestBuilder.CreateRandomSheetCreateRequest();
var sheet = SheetAggregate.CreateFromRequest(request);
//Act
sheet.ApproveSheet();
//Assert
sheet.IsApproved.Should().BeTrue();
sheet.ApprovedDate.Should().BeCloseTo(DateTime.Now);
}
public void SheetAggregate_CreateRandomFromRequest()
{
//Arrange
var request = AggregatesRequestBuilder.CreateRandomSheetCreateRequest();
//Act
var sheet = SheetAggregate.CreateFromRequest(request);
// Assert
sheet.Amount.Amount.Should().Be(request.Amount);
sheet.ContractId.Should().Be(request.ContractId);
sheet.EmployeeId.Should().Be(request.EmployeeId);
sheet.ServiceId.Should().Be(request.ServiceId);
sheet.Date.Should().Be(request.Date);
}
public SheetAggregate CreateRandomSheet()
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <SheetDto, Sheet>());
var mapper = new Mapper(config);
var sheetDto = new SheetDto()
{
Amount = amountForRandomSheets,
ContractId = SheetContractId,
Date = DateTime.Now,
EmployeeId = SheetEmployeeId,
ServiceId = SheetServiceId
};
var result = SheetAggregate.CreateFromSheetDto(mapper.Map <SheetDto, Sheet>(sheetDto));
return(result);
}
public void InvoiceAggregate_CalculateSomeSum_AfterIncludeSomeSheets()
{
//Arrange
var invoiceRequest = AggregatesRequestBuilder.CreateRandomInvoiceCreateRequest();
var invoice = InvoiceAggregate.CreateFromRequest(invoiceRequest);
var sheets = new List <SheetAggregate>();
var sheetsCount = 3;
for (int i = 0; i < sheetsCount; i++)
{
var sheetRequest = AggregatesRequestBuilder.CreateRandomSheetCreateRequest();
sheets.Add(SheetAggregate.CreateFromRequest(sheetRequest));
}
//Act
invoice.IncludeSheets(sheets);
//Assert
invoice.Sum.Amount.Should().BeGreaterThan(0);
invoice.Sheets.Count.Should().Be(sheetsCount);
}
public async Task Update(Guid id, SheetRequest sheetRequest)
{
var sheet = SheetAggregate.CreateFromSheetRequest(sheetRequest);
await _sheetRepo.Update(sheet);
}
public async Task Update(SheetAggregate item)
{
_context.Sheets.Update(item);
await _context.SaveChangesAsync();
}
public async Task Add(SheetAggregate item)
{
await _context.Sheets.AddAsync(item);
await _context.SaveChangesAsync();
}
