/// <summary>
/// Calculates net, gross and VAT amount
/// </summary>
/// <param name="purchaseData">Input Purchase data</param>
/// <returns>Calculated purchase data</returns>
public Task <PurchaseDataModel> CalculatePurchaseInfo(PurchaseDataModel purchaseData)
{
ValidateRequest(purchaseData);
var vatrate = purchaseData.VATRate / 100M;
if (purchaseData.VATAmount != 0 && purchaseData.VATAmount != null)
{
purchaseData.GrossAmount = Math.Round((purchaseData.VATAmount.Value * (1 + vatrate) / vatrate), 2);
purchaseData.NetAmount = Math.Round((purchaseData.VATAmount.Value / vatrate), 2);
return(Task.FromResult(purchaseData));
}
if (purchaseData.GrossAmount != 0 && purchaseData.GrossAmount != null)
{
purchaseData.VATAmount = Math.Round(purchaseData.GrossAmount.Value * (vatrate) / (1 + vatrate), 2);
purchaseData.NetAmount = Math.Round(purchaseData.GrossAmount.Value / (1 + vatrate), 2);
return(Task.FromResult(purchaseData));
}
if (purchaseData.NetAmount != 0 && purchaseData.NetAmount != null)
{
purchaseData.GrossAmount = Math.Round((purchaseData.NetAmount.Value * (1 + vatrate)), 2);
purchaseData.VATAmount = Math.Round((purchaseData.NetAmount.Value * vatrate), 2);
return(Task.FromResult(purchaseData));
}
return(Task.FromResult(purchaseData));
}
public async Task <IActionResult> Post([FromBody] PurchaseDataModel purchaseData)
{
return(Ok(await Mediator.Send(new CalculatePurchaseCommand
{
GrossAmount = purchaseData.GrossAmount,
NetAmount = purchaseData.NetAmount,
VATAmount = purchaseData.VATAmount,
VATRate = purchaseData.VATRate
})));
}
public ActionResult Add()
{
PurchaseDataModel model = new PurchaseDataModel();
model.Date = DateTime.Now;
model.GoodsList = GetGoodsList();
model.SupplierList = GetSupplierList();
model.WarehouseList = GetWarehouseList();
model.SpecificationList = GetSpecificationList();
model.GoodsTypeList = GetGoodsTypeList();
return(View(model));
}
public ActionResult Add(PurchaseDataModel model)
{
if (ModelState.IsValid)
{
PurchaseData Purchase = model.MapTo <PurchaseDataModel, PurchaseData>();
InventoryData inventoryData = new InventoryData()
{
WarehouseID = model.WarehouseID,
WarehouseName = model.WarehouseName,
GoodsID = model.GoodsID,
GoodsName = model.GoodsName,
Unit = model.Unit,
Specification = model.Specification,
GoodsType = model.GoodsType,
Brand = model.Brand,
InventoryQuantity = model.Quantity,
CostPrice = ((model.Quantity != 0) ? (model.Sum / Convert.ToDecimal(model.Quantity)) : 0),
InventorySum = model.Sum,
SupplierID = model.SupplierID,
SupplierName = model.SupplierName,
SupplierAddress = model.SupplierAddress,
PurchaseDate = DateTime.Now,
ShipmentsDate = DateTime.Now,
LastInventoryDate = DateTime.Now,
FinalSaleDate = DateTime.Now,
Active = "1",
ShipmentsQuantity = 0,
RemainingQuantity = model.Quantity
};
//添加货物库存表返回ID
int inventoryDataID = _inventoryDataService.Insert(inventoryData);
Purchase.InventoryDataID = inventoryDataID;
Purchase.Active = "1";
_purchaseDataService.Insert(Purchase);
return(RedirectToAction("Index"));
}
model.GoodsList = GetGoodsList();
model.SupplierList = GetSupplierList();
model.WarehouseList = GetWarehouseList();
model.SpecificationList = GetSpecificationList();
model.GoodsTypeList = GetGoodsTypeList();
return(View(model));
}
private void ValidateRequest(PurchaseDataModel purchaseData)
{
IDictionary <string, string[]> errors = new Dictionary <string, string[]>();
//Valid VAT rate for Austria - 10, 13, 20
if (purchaseData.VATRate != 10 && purchaseData.VATRate != 13 && purchaseData.VATRate != 20)
{
errors.Add(nameof(purchaseData.VATRate), new string[] { "Mandatory Field. Valid VAT rates for Austria are 10, 13, 20" });
}
if (purchaseData.GrossAmount == null && purchaseData.NetAmount == null && purchaseData.VATAmount == null)
{
errors.Add(nameof(PurchaseDataModel),
new string[] { "There should be at least one Input" });
}
if (purchaseData.GrossAmount == 0 || purchaseData.NetAmount == 0 || purchaseData.VATAmount == 0)
{
errors.Add(nameof(PurchaseDataModel),
new string[] { "Input values should not be 0" });
}
if (purchaseData.GrossAmount > 0 && (purchaseData.NetAmount != null || purchaseData.VATAmount != null))
{
errors.Add(nameof(purchaseData.GrossAmount),
new string[] { "Only one input is allowed" });
}
if (purchaseData.NetAmount > 0 && (purchaseData.GrossAmount != null || purchaseData.VATAmount != null))
{
errors.Add(nameof(purchaseData.NetAmount),
new string[] { "Only one input is allowed" });
}
if (purchaseData.VATAmount > 0 && (purchaseData.NetAmount != null || purchaseData.GrossAmount != null))
{
errors.Add(nameof(purchaseData.VATAmount),
new string[] { "Only one input is allowed" });
}
if (errors.Count > 0)
{
throw new ValidationException(errors);
}
}
public async void Should_ValidateInputPurchaseDataModel_With_ExpectedResult(PurchaseDataModel purchaseData, bool expectedResult)
{
//Arrange
IPurchaseService purchaseService = new PurchaseService();
//Act & Assert
if (expectedResult == false)
{
await Assert.ThrowsAsync<ValidationException>(async () => await purchaseService.CalculatePurchaseInfo(new PurchaseDataModel { VATRate = purchaseData.VATRate, GrossAmount = purchaseData.GrossAmount, NetAmount = purchaseData.NetAmount, VATAmount = purchaseData.VATAmount }));
}
else
{
var result = await purchaseService.CalculatePurchaseInfo(new PurchaseDataModel { VATRate = purchaseData.VATRate, GrossAmount = purchaseData.GrossAmount, NetAmount = purchaseData.NetAmount, VATAmount = purchaseData.VATAmount });
Assert.IsType<PurchaseDataModel>(result);
Assert.Equal(purchaseData.VATRate, result.VATRate);
}
}
public async Task Should_GetSuccessJSONResponse_When_ValidJsonPurchaseInfoSupplied(string paymentInfoJson, string expectedResponseJson)
{
//Arrange
var client = _factory.GetAnonymousClient();
var apiEndPoint = "/api/purchase";
var contentGrossAmount = Utilities.GetRequestContentFromJSONString(paymentInfoJson);
PurchaseDataModel expectedResponseObj = JsonConvert.DeserializeObject <PurchaseDataModel>(expectedResponseJson);
//Act
var httpResponse = await client.PostAsync(apiEndPoint, contentGrossAmount);
var responseString = await httpResponse.Content.ReadAsStringAsync();
PurchaseDataModel responseObj = JsonConvert.DeserializeObject <PurchaseDataModel>(responseString);
// Assert - HTTP success response
Assert.True(httpResponse.IsSuccessStatusCode);
//Assert - compare httpresponse with expectedResponse
Assert.Equal(expectedResponseObj.VATRate, responseObj.VATRate);
Assert.Equal(expectedResponseObj.GrossAmount, responseObj.GrossAmount);
Assert.Equal(expectedResponseObj.NetAmount, responseObj.NetAmount);
Assert.Equal(expectedResponseObj.VATAmount, responseObj.VATAmount);
}
public async void Should_CalculateAndComparePurchaseData_With_PreCalculatedPurchaseData(PurchaseDataModel purchaseData)
{
// Arrange
IPurchaseService purchaseService = new PurchaseService();
// Act
var resultGrossAmount = await purchaseService.CalculatePurchaseInfo(new PurchaseDataModel { VATRate = purchaseData.VATRate, GrossAmount = purchaseData.GrossAmount });
var resultVATAmount = await purchaseService.CalculatePurchaseInfo(new PurchaseDataModel { VATRate = purchaseData.VATRate, VATAmount = purchaseData.VATAmount });
var resultNetAmount = await purchaseService.CalculatePurchaseInfo(new PurchaseDataModel { VATRate = purchaseData.VATRate, NetAmount = purchaseData.NetAmount });
// Assert
Assert.Equal(purchaseData.VATRate, resultGrossAmount.VATRate);
Assert.Equal(purchaseData.GrossAmount, resultGrossAmount.GrossAmount);
Assert.Equal(purchaseData.VATAmount, resultGrossAmount.VATAmount);
Assert.Equal(purchaseData.NetAmount, resultGrossAmount.NetAmount);
Assert.Equal(purchaseData.VATRate, resultVATAmount.VATRate);
Assert.Equal(purchaseData.GrossAmount, resultVATAmount.GrossAmount);
Assert.Equal(purchaseData.VATAmount, resultVATAmount.VATAmount);
Assert.Equal(purchaseData.NetAmount, resultVATAmount.NetAmount);
Assert.Equal(purchaseData.VATRate, resultNetAmount.VATRate);
Assert.Equal(purchaseData.GrossAmount, resultNetAmount.GrossAmount);
Assert.Equal(purchaseData.VATAmount, resultNetAmount.VATAmount);
Assert.Equal(purchaseData.NetAmount, resultNetAmount.NetAmount);
}
public async Task <IActionResult> Post([FromBody] PurchaseDataModel purchaseData)
{
return(Ok(await _purchaseService.CalculatePurchaseInfo(purchaseData)));
}