private int Calculate(string operation)
{
if (!ModelState.IsValid)
{
return(0);
}
switch (operation)
{
case "add":
return(calc.Calculate(
new AddOperation(Left, Right)
));
case "subtract":
return(calc.Calculate(
new SubtractOperation(Left, Right)
));
case "multiply":
return(calc.Calculate(
new MultiplyOperation(Left, Right)
));
default:
return(int.MinValue);
}
}
public ActionResult CombinedWith(decimal pa, decimal pb)
{
var calculation = new CombinedWithCalculation(pa, pb);
var result = _calculatorService.Calculate(calculation);
return(Ok(result));
}
public void GivenSpecialCondition_WhenEnterEarly_ThenReturnEarlyBirdRate()
{
List <CalculatorCase> cases = new List <CalculatorCase>()
{
// Edge case
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2017, 1, 2, 6, 0, 0),
Exit = new DateTime(2017, 1, 2, 15, 30, 0)
},
Expected = new ParkingRateDto()
{
Name = "Early Bird",
Price = 13
}
},
// Edge case
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2017, 1, 2, 9, 0, 0),
Exit = new DateTime(2017, 1, 2, 23, 30, 0)
},
Expected = new ParkingRateDto()
{
Name = "Early Bird",
Price = 13
}
},
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2017, 1, 2, 7, 0, 0),
Exit = new DateTime(2017, 1, 2, 10, 00, 0)
},
Expected = new ParkingRateDto()
{
Name = "Early Bird",
Price = 13
}
}
};
foreach (var c in cases)
{
var result = _calculatorService.Calculate(c.TimerData).Result;
Assert.AreEqual(c.Expected.Name, result.Name);
Assert.AreEqual(c.Expected.Price, result.Price);
}
}
public void CalculationIsCorrect_BaseAmount(double baseAmount, double interestRatePercent, CompoundInterval compoundInterval,
double monthlyDeposit, short calcPeriodYrs, double lastExpectedTotalDeposits, double lastExpectedYearInterest,
double lastExpectedTotalInterest, double lastExpectedBalance)
{
CalculationResult[] result = _sut.Calculate(baseAmount, interestRatePercent, compoundInterval, monthlyDeposit, calcPeriodYrs);
CalculationResult lastYear = result.Last();
Assert.Equal(lastExpectedTotalDeposits, lastYear.TotalDeposits);
Assert.Equal(lastExpectedYearInterest, lastYear.YearInterest);
Assert.Equal(lastExpectedTotalInterest, lastYear.TotalInterest);
Assert.Equal(lastExpectedBalance, lastYear.Balance);
}
public void Calculate_Given_Calculation_Type_And_Numbers_When_Add_Then_Return_Correct_Result()
{
// Arrange
operationServiceMock
.Setup(x => x.Add(It.IsAny <decimal>(), It.IsAny <decimal>()))
.Returns(4);
// Act
var result = sut.Calculate(OperationType.Add, 2m, 2m);
// Assert
result.Should().Be(4);
}
public void Calculate_WhenCall_ReturnedResult()
{
const decimal expectedValue = 5;
var data = new CalculationData {
MathOperation = MathOperations.Multiply, Operand1 = 1, Operand2 = 1
};
_providerMock.Setup(x => x.Get(It.IsAny <MathOperations>())).Returns((x, y) => expectedValue);
var result = _service.Calculate(data);
Assert.IsTrue(result.IsOk);
Assert.AreEqual(expectedValue, result.Value);
}
public void OnNavigatedTo(NavigationParameters parameters)
{
if (parameters.ContainsKey("calculationInput"))
{
CalculationInput = (CalculationInput)parameters["calculationInput"];
CalculationOutput = (CalculationOutput)_calculatorService.Calculate(_calculationInput);
if (parameters.ContainsKey("Summary"))
{
if ((bool)parameters["Summary"])
{
OriginalWorkingDistance = CalculationInput.WorkingDistance;
OriginalIncidentEnergy = CalculationOutput.IncidentEnergy;
}
}
//InitResultP1();
//InitResultP2();
//InitResultP3();
//InitResults();
//_eventAggregator.GetEvent<CalculationInputUpdated>().Subscribe(HandleCalculationInputUpdated);
InitResultP1();
InitResultP2();
InitResultP3();
InitResults();
}
}
public async Task <ActionResult <MessageModel> > Test(CalculatorRequestModel request)
{
var cur1 = request.Curr1;
var cur2 = request.Curr2;
return(await _calculatorService.Calculate(cur1, cur2));
}
private static void Calculate(ICalculatorService calculator)
{
Console.WriteLine("Enter expression:");
var name = Console.ReadLine();
var result = calculator.Calculate(name);
Console.WriteLine("Result: {0}", result);
}
public void EarlyEntry_EarlyExit_RateTest()
{
List <CalculatorCase> testCases = new List <CalculatorCase>()
{
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2020, 7, 6, 6, 0, 0), Exit = new DateTime(2020, 7, 6, 15, 30, 0)
},
ExpectedData = new ParkingRateDto()
{
Name = "Early Bird", Price = 13
}
},
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2020, 7, 6, 9, 0, 0), Exit = new DateTime(2020, 7, 6, 23, 30, 0)
},
ExpectedData = new ParkingRateDto()
{
Name = "Early Bird", Price = 13
}
},
new CalculatorCase()
{
TimerData = new TimerDto()
{
Entry = new DateTime(2020, 7, 6, 7, 0, 0), Exit = new DateTime(2020, 7, 6, 10, 30, 0)
},
ExpectedData = new ParkingRateDto()
{
Name = "Early Bird", Price = 13
}
}
};
foreach (var c in testCases)
{
var result = _calculatorService.Calculate(c.TimerData).Result;
Assert.AreEqual(c.ExpectedData.Name, result.Name);
Assert.AreEqual(c.ExpectedData.Price, result.Price);
}
}
private static void Calculate(ICalculatorService calculator)
{
Console.WriteLine("Enter expression:");
var name = Console.ReadLine();
var result = calculator.Calculate(name);
Console.WriteLine("Result: {0}", result);
}
public async Task <IHttpActionResult> Post(Calculation calculation)
{
_calculatorService.Calculate(calculation.CalculationString);
// _calculationService.Add(calculation);
// await _calculationService.SaveChangesAsync();
return(Ok(calculation.CalculationString + " added to database"));
}
private void equal_Click(object sender, System.EventArgs e)
{
if (!calculatorService.Calculate())
{
return;
}
SetInputValue(calculatorService.Input);
}
public async Task <string> ProcessAsync(TimerDto input)
{
var response = await _calculatorService.Calculate(input);
var result =
"\nPackage : " + response.Name +
"\nTOTAL COST : " + response.Price.ToString("C");
return(result);
}
public IActionResult Post(CalculatorRequestDto calculatorRequestDto)
{
if (ModelState.IsValid)
{
var result = _calculatorService.Calculate(calculatorRequestDto);
return(Ok(result));
}
return(BadRequest(ModelState));
}
public IHttpActionResult Calculate(decimal[] values)
{
try
{
return(Ok(new { status = "success", result = _calculatorService.Calculate(values) }));
}
catch (Exception ex)
{
return(Ok(new { status = "error", result = ex.Message }));
}
}
public void OnNavigatedTo(NavigationParameters parameters)
{
if (parameters.ContainsKey("calculationInput"))
{
CalculationInput = (CalculationInput)parameters["calculationInput"];
CalculationOutput = (CalculationOutput)_calculatorService.Calculate(_calculationInput);
InitList();
initCarousel();
ItemSource = new List <int>();
}
}
//public CalculatorController(ICalculatorService calculatorService)
//{
// _calculatorService = calculatorService;
//}
// [System.Web.Http.HttpGet("Calculate")]
public IHttpActionResult Calculate(CalculateParams param)
{
var result = _calculatorService.Calculate(param.Sign, param.FirstValue, param.SecondValue);
var resultData = new ResultData
{
Result = result,
ErrorMessage = string.Empty
};
return(Ok(resultData));
}
public int StringCalculator(string input)
{
if (input.Contains("-"))
{
throw new System.ArgumentException("Must be positive number");
}
if (String.IsNullOrWhiteSpace(input))
{
return(0);
}
if (input.Contains(",") || input.Contains("\n"))
{
return(_calculatorService.Calculate(input));
// char[] separator = {',', '\n'};
// var numbers = input.Split(separator);
// var sum = 0;
// foreach (var number in numbers)
// {
// var convertedInt = Convert.ToInt32(number);
// if (convertedInt <= 1000)
// sum += convertedInt;
// }
// return sum;
}
// if (input.Contains(","))
// {
// var numbers = input.Split(',');
// var sum = 0;
// foreach (var number in numbers)
// {
// sum += Convert.ToInt32(number);
// }
// return sum;
// }
// if (input.Contains("\n"))
// {
// var numbers = input.Split('\n');
// var sum = 0;
// foreach (var number in numbers)
// {
// sum += Convert.ToInt32(number);
// }
// return sum;
// }
return(Convert.ToInt32(input));
}
public OperationResult Calculate(CalculationRequest request)
{
var validationResult = _calculationRequestValidator.Validate(request);
if (!validationResult.IsOk)
{
return(new OperationResult(validationResult.ErrorMessage));
}
var calculationData = ParseRequest(request);
return(_calculator.Calculate(calculationData));
}
public async Task <IActionResult> Post([FromBody] CalculateRequestDto requestDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (requestDto.ShippingToCountryIso == "CA" && String.IsNullOrEmpty(requestDto.CanadianProvinceCode))
{
return(BadRequest("You must specify the property CanadianProvinceCode with a valu for Canadian calculations"));
}
return(Ok(_calculatorService.Calculate(requestDto)));
}
public void RefinancingLoanWithNoFees()
{
var requestModel = new RefinancingLoanRequestModel
{
LoanAmount = 1000,
Interest = 10,
Period = 12,
CountOfPaidInstallments = 2,
EarlyInstallmentsFee = 0,
NewInterest = 2,
StartingFeesCurrency = 0,
StartingFeesPercent = 0
};
var actual = _service.Calculate(requestModel, null);
var expected = new RefinancingLoanResponseModel
{
Status = System.Net.HttpStatusCode.OK,
CurrentLoan = new RefinancingLoanHelperModel
{
Interest = 10,
Period = 12,
EarlyInstallmentsFee = 0,
MonthlyInstallment = 87.92M,
//Total = 879.16M
Total = 879.20M
},
NewLoan = new RefinancingLoanHelperModel
{
Interest = 2,
Period = 10,
EarlyInstallmentsFee = 0,
//MonthlyInstallment = 84.79M,
MonthlyInstallment = 84.77M,
//Total = 847.89M
Total = 847.70M
}
};
Assert.AreEqual(actual, expected);
}
private void CalculateClick(bool clicked)
{
if (clicked)
{
HasStandardWorkingDistance = !CalculationInput.HasCustomWorkingDistance;
CalculationOutput = _calculatorService.Calculate(CalculationInput) as CalculationOutput;
CalculationOutput.IncidentEnergy = Math.Round(CalculationOutput.IncidentEnergy, 2, MidpointRounding.ToEven);
WorkingDistanceRounded = Math.Round(CalculationInput.WorkingDistance.Value, 2, MidpointRounding.ToEven);
OverFortyCal = CalculationOutput.IncidentEnergy > 40.00m;
IsLevelZero = CalculationOutput.IncidentEnergy <= 1.2m;
IsLevelTwo = CalculationOutput.IncidentEnergy > 1.2m && CalculationOutput.IncidentEnergy <= 8;
IsLevelFour = CalculationOutput.IncidentEnergy > 8 && CalculationOutput.IncidentEnergy <= 40;
ShowFindSafeWorkingDistance = OverFortyCal || CalculationInput.HasCustomWorkingDistance;
_eventAggregator.GetEvent <CalculationOutputUpdated>().Publish(CalculationOutput);
}
}
public async Task <IActionResult> GetAsync(string left, string right, string operation)
{
var responce = new Dictionary <string, string>();
try
{
var result = _calculator.Calculate(left, right, operation);
var id = await _resultsRepository.Save(result);
_logger.LogInformation($"Result: {result}, Id: {id}");
responce.Add("result", result);
responce.Add("id", id);
return(new JsonResult(responce));
}
catch (Exception e)
{
_logger.LogError(e, $"Error: {e.Message}");
responce.Add("error", e.Message);
return(new JsonResult(responce));
}
}
public IActionResult Post([FromBody] RequestDto request)
{
return(new OkObjectResult(calculatorService.Calculate(request)));
}
public ActionResult <CloudCombinationResultDTO> Calculate([FromBody] CloudCombinationDTO cloudCombination)
{
return(_calculatorService.Calculate(cloudCombination));
}
public LeasingLoanResponseModel CalculateLeasingLoan([FromBody] LeasingLoanRequestModel requestModel)
{
string cookieValue = Request.Cookies["Auth-Tst"];
return(_leasingLoanService.Calculate(requestModel, cookieValue));
}
public RefinancingLoanResponseModel CalculateRefinancingLoan([FromBody] RefinancingLoanRequestModel requestModel)
{
string cookieValue = Request.Cookies["Auth-Tst"];
return(_refinancingLoanService.Calculate(requestModel, cookieValue));
}
public void ExpressionCalculate_Success(string expression, double expectedResult)
{
var actualResult = calculatorService.Calculate(expression);
Assert.AreEqual(expectedResult, actualResult);
}
public void TestCalculate2Numbers()
{
var result = _calculatorService.Calculate("1,2");
Assert.IsTrue(result == 3);
result = _calculatorService.Calculate("20");
Assert.IsTrue(result == 20);
result = _calculatorService.Calculate("5,dfaadf");
Assert.IsTrue(result == 5);
}
public void PushOperator(string op)
{
CalculatorService.Calculate(op);
}
