public async Task <ActionResult <List <NPVSet> > > Post([FromBody] CalculateSetOfNPVRequest request)
{
var getNPVPreviousRequestBy = new NPVPreviousRequest
{
CashFlowsDescription = string.Join(", ", request.CashFlow.ToArray())
, IncrementRate = request.Increment
, InitialCost = request.InitialCost
, LowerBoundDiscountRate = request.LowerBoundDiscountRate
, UpperBoundDiscountRate = request.UpperBoundDiscountRate
};
var npvEngine = new NPVEngine.NPVEngine();
request.InitialCost = request.InitialCost * -1;
var npvSet = npvEngine.CalculateSetOfNPV(request);
getNPVPreviousRequestBy.NPVPreviousResults = new List <NPVPreviousResult>();
npvSet.ForEach(s => {
getNPVPreviousRequestBy.NPVPreviousResults.Add(
new NPVPreviousResult
{
DiscountRate = s.DiscountRate
, NPV = s.NPV
}
);
});
await _npvDataAccess.SaveNPVPreviousRequest(getNPVPreviousRequestBy);
return(Ok(npvSet));
}
public void CalculateSetOfNPV_Given_All_Parameters_Is_Valid(
double initialCost
, double upperLimit
, double lowerLimit
, double increment)
{
var request = new CalculateSetOfNPVRequest
{
CashFlow = new List <double>
{
1000
, 1500
, 2000
, 2500
, 3000
},
UpperBoundDiscountRate = upperLimit
, LowerBoundDiscountRate = lowerLimit
, Increment = increment
, InitialCost = initialCost
};
var cashFlowSummary = string.Join(", ", request.CashFlow.ToArray());
var npvEngine = new NPVEngine.NPVEngine();
var expectedOutput = new List <NPVSet>();
while (lowerLimit <= upperLimit)
{
expectedOutput.Add(new NPVSet
{
CashFlowSummary = cashFlowSummary
, InitialCost = initialCost * -1
, DiscountRate = lowerLimit
, NPV = npvEngine.CalculateIndividualNPV(new CalculateIndividualNPVRequest
{
CashFlows = request.CashFlow
,
InitialValue = request.InitialCost
,
Interest = lowerLimit / 100
})
});
lowerLimit += increment;
}
var actualOutput = npvEngine.CalculateSetOfNPV(request);
for (var i = 0; i < expectedOutput.Count; i++)
{
Assert.AreEqual(expectedOutput[i].CashFlowSummary, actualOutput[i].CashFlowSummary);
Assert.AreEqual(expectedOutput[i].DiscountRate, actualOutput[i].DiscountRate);
Assert.AreEqual(Math.Round(expectedOutput[i].NPV, 2), actualOutput[i].NPV);
}
}
public List <NPVSet> CalculateSetOfNPV(CalculateSetOfNPVRequest request)
{
var totalDiscountInterestRateRequest = new GetTotalDiscountRateIncrementRowsRequest
{
Increment = request.Increment
,
UpperBoundDiscountRate = request.UpperBoundDiscountRate
,
LowerBoundDiscountRate = request.LowerBoundDiscountRate
};
ValidateInputs(totalDiscountInterestRateRequest, request);
var listOfInterests = BuildConcurrentCollectionOfInterest(totalDiscountInterestRateRequest);
var dictionary = new ConcurrentDictionary <double, NPVSet>();
Parallel.ForEach(listOfInterests, (interest) =>
{
var discountRate = interest / 100;
var npv = CalculateIndividualNPV(new CalculateIndividualNPVRequest {
CashFlows = request.CashFlow
, InitialValue = request.InitialCost
, Interest = discountRate
});
var npvSet = new NPVSet
{
CashFlowSummary = string.Join(", ", request.CashFlow.ToArray())
,
DiscountRate = interest
,
InitialCost = Math.Abs(request.InitialCost)
,
NPV = Math.Round(npv, 2)
};
dictionary.AddOrUpdate(interest, npvSet, (dr, set) => npvSet);
});
var listOfKeys = dictionary.Keys.ToList();
listOfKeys.Sort();
var finalList = new List <NPVSet>();
listOfKeys.ForEach(k =>
{
finalList.Add(dictionary[k]);
});
return(finalList);
}
public void CalculateSetOfNPV_Given_Increment_Is_Invalid_Expect_Exception()
{
var npvEngine = new NPVEngine.NPVEngine();
var request = new CalculateSetOfNPVRequest
{
CashFlow = new List <double>
{
1000
, 1500
, 2000
, 2500
, 3000
},
UpperBoundDiscountRate = 1.5
,
LowerBoundDiscountRate = 1.0
,
Increment = .8
,
InitialCost = -1000
};
Assert.Throws <ArgumentException>(() => npvEngine.CalculateSetOfNPV(request));
}
public void Post_Given_Request_Has_Not_Been_Made_Before_Returns_Ok(
double upperLimit
, double lowerLimit
, double increment
, double initialCost
)
{
var request = new CalculateSetOfNPVRequest
{
CashFlow = new List <double>
{
1000
, 1500
, 2000
, 2500
, 3000
},
UpperBoundDiscountRate = upperLimit
,
LowerBoundDiscountRate = lowerLimit
,
Increment = increment
,
InitialCost = initialCost
};
var cashFlowSummary = string.Join(", ", request.CashFlow.ToArray());
var npvEngine = new NPVEngine.NPVEngine();
var expectedOutput = new List <NPVSet>();
var npvPreviousResults = new List <NPVPreviousResult>();
var id = 1;
while (lowerLimit <= upperLimit)
{
var npv = npvEngine.CalculateIndividualNPV(new CalculateIndividualNPVRequest
{
CashFlows = request.CashFlow
,
InitialValue = request.InitialCost * -1
,
Interest = lowerLimit / 100
});
expectedOutput.Add(new NPVSet
{
CashFlowSummary = cashFlowSummary
,
InitialCost = initialCost * -1
,
DiscountRate = lowerLimit
,
NPV = npv
});
npvPreviousResults.Add(new NPVPreviousResult
{
Id = id
, DiscountRate = lowerLimit
, NPV = Math.Round(npv, 2)
});
lowerLimit += increment;
id += 1;
}
var nPVPreviousRequestAfterSave = new NPVPreviousRequest
{
CashFlowsDescription = cashFlowSummary
,
Id = 1
,
IncrementRate = increment
,
InitialCost = initialCost
,
LowerBoundDiscountRate = lowerLimit
,
UpperBoundDiscountRate = upperLimit
,
NPVPreviousResults = npvPreviousResults
};
_npvDataAccessMock.Setup(n => n.SaveNPVPreviousRequest(It.IsAny <NPVPreviousRequest>()))
.Returns(Task.FromResult(nPVPreviousRequestAfterSave));
var result = _controller.Post(request);
var actualResult = result.Result.Result as OkObjectResult;
var actualOutput = actualResult.Value as List <NPVSet>;
for (var i = 0; i < expectedOutput.Count; i++)
{
Assert.AreEqual(expectedOutput[i].CashFlowSummary, actualOutput[i].CashFlowSummary);
Assert.AreEqual(expectedOutput[i].DiscountRate, actualOutput[i].DiscountRate);
Assert.AreEqual(Math.Round(expectedOutput[i].NPV, 2), actualOutput[i].NPV);
}
_npvDataAccessMock.VerifyAll();
}
