public async void Delete()
{
var mock = new ServiceMockFacade <ISalesTerritoryRepository>();
var model = new ApiSalesTerritoryRequestModel();
mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
var service = new SalesTerritoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SalesTerritoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLSalesTerritoryMapperMock,
mock.DALMapperMockFactory.DALSalesTerritoryMapperMock,
mock.BOLMapperMockFactory.BOLCustomerMapperMock,
mock.DALMapperMockFactory.DALCustomerMapperMock,
mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
mock.BOLMapperMockFactory.BOLSalesPersonMapperMock,
mock.DALMapperMockFactory.DALSalesPersonMapperMock,
mock.BOLMapperMockFactory.BOLSalesTerritoryHistoryMapperMock,
mock.DALMapperMockFactory.DALSalesTerritoryHistoryMapperMock);
ActionResponse response = await service.Delete(default(int));
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
mock.ModelValidatorMockFactory.SalesTerritoryModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
}
public async void Update()
{
var mock = new ServiceMockFacade <ISalesTerritoryRepository>();
var model = new ApiSalesTerritoryRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <SalesTerritory>())).Returns(Task.FromResult(new SalesTerritory()));
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new SalesTerritory()));
var service = new SalesTerritoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SalesTerritoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLSalesTerritoryMapperMock,
mock.DALMapperMockFactory.DALSalesTerritoryMapperMock,
mock.BOLMapperMockFactory.BOLCustomerMapperMock,
mock.DALMapperMockFactory.DALCustomerMapperMock,
mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
mock.BOLMapperMockFactory.BOLSalesPersonMapperMock,
mock.DALMapperMockFactory.DALSalesPersonMapperMock,
mock.BOLMapperMockFactory.BOLSalesTerritoryHistoryMapperMock,
mock.DALMapperMockFactory.DALSalesTerritoryHistoryMapperMock);
UpdateResponse <ApiSalesTerritoryResponseModel> response = await service.Update(default(int), model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.SalesTerritoryModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiSalesTerritoryRequestModel>()));
mock.RepositoryMock.Verify(x => x.Update(It.IsAny <SalesTerritory>()));
}
private async Task <ApiSalesTerritoryResponseModel> CreateRecord(ApiClient client)
{
var model = new ApiSalesTerritoryRequestModel();
model.SetProperties(2m, 2m, "B", "B", DateTime.Parse("1/1/1988 12:00:00 AM"), "B", Guid.Parse("3842cac4-b9a0-8223-0dcc-509a6f75849b"), 2m, 2m);
CreateResponse <ApiSalesTerritoryResponseModel> result = await client.SalesTerritoryCreateAsync(model);
result.Success.Should().BeTrue();
return(result.Record);
}
public async Task <ValidationResult> ValidateUpdateAsync(int id, ApiSalesTerritoryRequestModel model)
{
this.CostLastYearRules();
this.CostYTDRules();
this.CountryRegionCodeRules();
this.@GroupRules();
this.ModifiedDateRules();
this.NameRules();
this.RowguidRules();
this.SalesLastYearRules();
this.SalesYTDRules();
return(await this.ValidateAsync(model, id));
}
public virtual async Task <IActionResult> Create([FromBody] ApiSalesTerritoryRequestModel model)
{
CreateResponse <ApiSalesTerritoryResponseModel> result = await this.SalesTerritoryService.Create(model);
if (result.Success)
{
return(this.Created($"{this.Settings.ExternalBaseUrl}/api/SalesTerritories/{result.Record.TerritoryID}", result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
public virtual async Task <CreateResponse <ApiSalesTerritoryResponseModel> > Create(
ApiSalesTerritoryRequestModel model)
{
CreateResponse <ApiSalesTerritoryResponseModel> response = new CreateResponse <ApiSalesTerritoryResponseModel>(await this.salesTerritoryModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
var bo = this.bolSalesTerritoryMapper.MapModelToBO(default(int), model);
var record = await this.salesTerritoryRepository.Create(this.dalSalesTerritoryMapper.MapBOToEF(bo));
response.SetRecord(this.bolSalesTerritoryMapper.MapBOToModel(this.dalSalesTerritoryMapper.MapEFToBO(record)));
}
return(response);
}
private async Task <ApiSalesTerritoryRequestModel> PatchModel(int id, JsonPatchDocument <ApiSalesTerritoryRequestModel> patch)
{
var record = await this.SalesTerritoryService.Get(id);
if (record == null)
{
return(null);
}
else
{
ApiSalesTerritoryRequestModel request = this.SalesTerritoryModelMapper.MapResponseToRequest(record);
patch.ApplyTo(request);
return(request);
}
}
public void MapModelToBO()
{
var mapper = new BOLSalesTerritoryMapper();
ApiSalesTerritoryRequestModel model = new ApiSalesTerritoryRequestModel();
model.SetProperties(1m, 1m, "A", "A", DateTime.Parse("1/1/1987 12:00:00 AM"), "A", Guid.Parse("8420cdcf-d595-ef65-66e7-dff9f98764da"), 1m, 1m);
BOSalesTerritory response = mapper.MapModelToBO(1, model);
response.CostLastYear.Should().Be(1m);
response.CostYTD.Should().Be(1m);
response.CountryRegionCode.Should().Be("A");
[email protected]().Be("A");
response.ModifiedDate.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM"));
response.Name.Should().Be("A");
response.Rowguid.Should().Be(Guid.Parse("8420cdcf-d595-ef65-66e7-dff9f98764da"));
response.SalesLastYear.Should().Be(1m);
response.SalesYTD.Should().Be(1m);
}
public virtual BOSalesTerritory MapModelToBO(
int territoryID,
ApiSalesTerritoryRequestModel model
)
{
BOSalesTerritory boSalesTerritory = new BOSalesTerritory();
boSalesTerritory.SetProperties(
territoryID,
model.CostLastYear,
model.CostYTD,
model.CountryRegionCode,
model.@Group,
model.ModifiedDate,
model.Name,
model.Rowguid,
model.SalesLastYear,
model.SalesYTD);
return(boSalesTerritory);
}
public virtual async Task <UpdateResponse <ApiSalesTerritoryResponseModel> > Update(
int territoryID,
ApiSalesTerritoryRequestModel model)
{
var validationResult = await this.salesTerritoryModelValidator.ValidateUpdateAsync(territoryID, model);
if (validationResult.IsValid)
{
var bo = this.bolSalesTerritoryMapper.MapModelToBO(territoryID, model);
await this.salesTerritoryRepository.Update(this.dalSalesTerritoryMapper.MapBOToEF(bo));
var record = await this.salesTerritoryRepository.Get(territoryID);
return(new UpdateResponse <ApiSalesTerritoryResponseModel>(this.bolSalesTerritoryMapper.MapBOToModel(this.dalSalesTerritoryMapper.MapEFToBO(record))));
}
else
{
return(new UpdateResponse <ApiSalesTerritoryResponseModel>(validationResult));
}
}
public void CreatePatch()
{
var mapper = new ApiSalesTerritoryModelMapper();
var model = new ApiSalesTerritoryRequestModel();
model.SetProperties(1m, 1m, "A", "A", DateTime.Parse("1/1/1987 12:00:00 AM"), "A", Guid.Parse("8420cdcf-d595-ef65-66e7-dff9f98764da"), 1m, 1m);
JsonPatchDocument <ApiSalesTerritoryRequestModel> patch = mapper.CreatePatch(model);
var response = new ApiSalesTerritoryRequestModel();
patch.ApplyTo(response);
response.CostLastYear.Should().Be(1m);
response.CostYTD.Should().Be(1m);
response.CountryRegionCode.Should().Be("A");
[email protected]().Be("A");
response.ModifiedDate.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM"));
response.Name.Should().Be("A");
response.Rowguid.Should().Be(Guid.Parse("8420cdcf-d595-ef65-66e7-dff9f98764da"));
response.SalesLastYear.Should().Be(1m);
response.SalesYTD.Should().Be(1m);
}
public virtual async Task <IActionResult> Update(int id, [FromBody] ApiSalesTerritoryRequestModel model)
{
ApiSalesTerritoryRequestModel request = await this.PatchModel(id, this.SalesTerritoryModelMapper.CreatePatch(model));
if (request == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
UpdateResponse <ApiSalesTerritoryResponseModel> result = await this.SalesTerritoryService.Update(id, request);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
}
public virtual async Task <IActionResult> Patch(int id, [FromBody] JsonPatchDocument <ApiSalesTerritoryRequestModel> patch)
{
ApiSalesTerritoryResponseModel record = await this.SalesTerritoryService.Get(id);
if (record == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
ApiSalesTerritoryRequestModel model = await this.PatchModel(id, patch);
UpdateResponse <ApiSalesTerritoryResponseModel> result = await this.SalesTerritoryService.Update(id, model);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
}
