private ActionResult GetCalculateCreditResult(CalculateCreditModel calculateCreditModel)
{
var calculatedData = this.creditManager.CalculateCredit(
calculateCreditModel.LoanProductId,
calculateCreditModel.Amount,
calculateCreditModel.Monthes);
// one more magic:) linque-magic:)
var months = -calculatedData.Payments.Count() + 1;
var model = new CalculationResultModel
{
MonthlyPayments = calculatedData.Payments.Select(x => new MonthlyPaymentViewModel
{
Payment = x.ToGBString(),
Month = DateTime.Today.AddMonths(months++).ToString("MMMMMMMMMM / yyyy", CultureInfo.InvariantCulture)
}),
TotalPayment = calculatedData.TotalPayment.ToGBString()
};
switch (calculateCreditModel.LoanProductType)
{
case LoanProductType.Anuitet:
return(this.View("CreditCalulator/CalculationResult/AnuitetCalculationResult", model));
case LoanProductType.Differential:
return(this.View("CreditCalulator/CalculationResult/DifferencialCalculationResult", model));
case LoanProductType.OneTimePayment:
return(this.View("CreditCalulator/CalculationResult/OneTimePaymentCalculationResult", model));
default:
throw new NotSupportedException();
}
}
public CalculationResultModel GetResult(CalculationDTO[] dto)
{
CalculationResultModel Models = new CalculationResultModel();
Models.Results = dto.Select(GetResult).ToArray();
return(Models);
}
public void ListAll()
{
requestMethod = ApiRequestMethod.GET;
response = client.MakeApiRequestAsync("/Api/values?All=list", requestMethod);
result = response.Result;
models = result.Deserialize <CalculationResultModel>();
Assert.IsNotNull(models);
}
public ActionResult Calculate(DimensionInputModel input)
{
var result = new GenericJsonResult();
if (!ModelState.IsValid)
{
result = new GenericJsonResult()
{
Data = PartialView("ErrorSection", ModelState.Where(x => x.Value.Errors.Any()).Select(x => $"{x.Key} : { String.Join(" ", x.Value.Errors.Select(y => y.ErrorMessage))}")).RenderToString(),
Success = false
};
}
else
{
var parameters = new CalculationCostParameters()
{
DimensionsParameters = new DimensionsParameters()
{
Depth = Convert.ToInt32(input.Depth),
Height = Convert.ToInt32(input.Height),
Width = Convert.ToInt32(input.Width)
},
WieghtParameters = new WeightParameters()
{
Weight = Convert.ToInt32(input.Weight)
}
};
CalculationResultModel calculationResult = packagePriceCalculation.CalculateCost(parameters);
var Packages = new List <PackageViewModel>();
Packages = calculationResult.SingleCompanyCosts.Select(x => new PackageViewModel()
{
CompanyName = x.CompanyName,
PriceTag = new PriceTagViewModel()
{
Currency = "EUR",
PriceType = x.CostType.ToString(),
PriceValue = x.Cost.ToString()
},
Promoted = x.Promoted
}).ToList();
result = new GenericJsonResult()
{
Data = PartialView("CalculationResult", Packages).RenderToString(),
Success = true
};
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public IActionResult Probability(int targetOutcomes, int totalOutcomes)
{
try
{
results = mathCalculator.Probability(targetOutcomes, totalOutcomes);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult AgebasedChildDose(int childAge, int adultDose)
{
try
{
results = pharmaceuticalCalculations.AgebasedChildDose(childAge, adultDose);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Density(double mass, double volume)
{
try
{
results = physicsCalculator.Density(mass, volume);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult AverageSpeed_Time(double aVGSpeed, double aVGtime)
{
try
{
results = physicsCalculator.AverageSpeed_Time(aVGSpeed, aVGtime);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult ChangeInTemperature(double initialTemperature, double finalTemperature)
{
try
{
results = physicsCalculator.ChangeInTemperature(initialTemperature, finalTemperature);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Ohm_Resistance(double voltage, double current)
{
try
{
results = physicsCalculator.Ohm_Resistance(voltage, current);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Ohm_VoltageCalculation(double current, double resistance)
{
try
{
results = physicsCalculator.Ohm_VoltageCalculation(current, resistance);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Heat_HeatCapacity(double energy, double mass, double aVATemperature)
{
try
{
results = physicsCalculator.Heat_HeatCapacity(energy, mass, aVATemperature);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Heat_Mass(double energy, double heat, double aVATemperature)
{
try
{
results = physicsCalculator.Heat_Mass(energy, heat, aVATemperature);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Volume(double weight, double density)
{
try
{
results = pharmaceuticalCalculations.Volume(weight, density);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Heat_ChangeOfTemperature(double energy, double mass, double heat)
{
try
{
results = physicsCalculator.Heat_ChangeOfTemperature(energy, mass, heat);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult BSA(double height, double weight)
{
try
{
results = pharmaceuticalCalculations.BSA(height, weight);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult ValueInProof(double alcoholStrengt)
{
try
{
results = pharmaceuticalCalculations.ValueInProof(alcoholStrengt);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Mean([FromBody] List <double> list)
{
try
{
results = mathCalculator.Mean(list);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult WeightBasedChildDose(double childBSA, double adultDose)
{
try
{
results = pharmaceuticalCalculations.WeightBasedChildDose(childBSA, adultDose);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Weight(double vloume, double density)
{
try
{
results = pharmaceuticalCalculations.Weight(vloume, density);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult SlopeIntercept(int x1, int y1, int slope)
{
try
{
results = mathCalculator.SlopeIntercept(new List <int> {
x1, y1
}, slope);
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public CalculationResultModel CalculateCost(CalculationCostParameters parameters)
{
var configs = companyCalculationConfigurationRepository.GetCofigs();
List <SingleCompanyCost> costs = configs.Companys.Select(x => CalculateCost(x, parameters)).Where(x => x != null).ToList();
costs = costs.OrderBy(x => x.Cost).ToList();
costs.First().Promoted = true;
var result = new CalculationResultModel()
{
SingleCompanyCosts = costs
};
return(result);
}
public IActionResult Slope(int x1, int y1, int x2, int y2)
{
try
{
results = mathCalculator.Slope(new List <int> {
x1, y1
}, new List <int> {
x2, y2
});
return(Ok(results));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
