public IActionResult Index(CalculateViewModel input, [FromServices] IValidationConfiguration validationConfiguration) // Action Injection
{
var validationErrors = new List <string>();
if (validationConfiguration.Calculate && _secondValidation.CalculateSecond == "true")
{
foreach (var rule in _numberRules)
{
if (!rule.Validate(input.Number))
{
validationErrors.Add(rule.ErrorMessage);
}
}
}
if (!validationErrors.Any())
{
validationErrors.Add("Value is valid.");
}
var returnToValidationErrors = string.Join("\n", validationErrors);
ModelState.AddModelError("", returnToValidationErrors);
return(View());
}
public ActionResult ModelBindingInParameters(int?Number1, int?Number2, string operation)
{
bool error = false;
int number1 = 0, number2 = 0;
if (Number1 == null)
{
this.ViewBag.Number1Null = "First number is NULL";
error = true;
}
if (Number2 == null)
{
this.ViewBag.Number2Null = "Second number is NULL";
error = true;
}
number1 = Convert.ToInt32(Number1);
number2 = Convert.ToInt32(Number2);
if (Number2 == 0 && operation == "/")
{
this.ViewBag.DividedByZero = "Division by zero";
error = true;
}
this.ViewBag.Number1 = number1;
this.ViewBag.Number2 = number2;
this.ViewBag.Operation = operation;
if (error)
{
return(this.View());
}
int result = 0;
switch (operation)
{
case "+":
result = calculateService.Summ(number1, number2); break;
case "-":
result = calculateService.Subtraction(number1, number2); break;
case "*":
result = calculateService.Multiplication(number1, number2); break;
case "/":
result = calculateService.Division(number1, number2); break;
}
var resultModel = new CalculateViewModel
{
ResultNumber = result
};
return(this.View("ModelBindingInParameters", resultModel));
}
public double?CalculateInterest(CalculateViewModel model)
{
var principal = model.Principal;
var rate = 1.0 + model.Rate / 100;
var multiplier = Math.Pow(rate ?? 0.0, model.Years ?? 0.0);
return(principal * multiplier);
}
public ActionResult Calculate(CalculateViewModel model)
{
var enterpriseId = int.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value);
var suggestion = _mapper.Map <SuggestionViewModel>(_ratingService.SaveAnswers(enterpriseId, model.RatingType, _mapper.Map <IEnumerable <Answer> >(model.Answers)));
return(View("Suggestion", suggestion));
}
public CalculateViewModel GetDeliveryCostPage(CalculateViewModel viewModel)
{
var model = new CalculateModel(viewModel, _deliveryCostCalculator, _config);
model.CalculateDeliveryCost();
return(model.ViewModel);
}
public IActionResult Index()
{
var model = new CalculateViewModel();
model.Request = HttpContext;
Console.WriteLine("formula:" + "test");
return(View(model));
}
public IActionResult Index(CalculateViewModel model)
{
if (ModelState.IsValid)
{
Calculator calc = new Calculator();
model.Result = calc.Add(model.FirstNumber, model.SecondNumber);
}
return(View(model));
}
public IActionResult Calculate(CalculatePostModel postModel)
{
var result = PythagoreanHandler.GetHypotenuse(postModel.SideOne, postModel.SideTwo);
var model = new CalculateViewModel
{
Result = result
};
return(View(model));
}
public IActionResult CalculateDay(Guid id)
{
var student = _studentInfos.Get(id);
var model = new CalculateViewModel
{
_Student = student,
result = predictDay(student)
};
return(View(model));
}
public IActionResult Calculate(string formula, string points, double taylorAround, uint taylorN, double startIntegral, double endIntegral)
{
if (string.IsNullOrEmpty(formula))
{
return(RedirectToAction("Index"));
}
var model = new CalculateViewModel();
model.Original = formula;
var parser = new StringParser(formula);
var result = parser.GetOperator();
model.NiceFormat = (result.DeepSimplyfy().ToMathString());
model.DerivativeNiceFormat = (result.Derivate().DeepSimplyfy().ToMathString());
model.DerivativePointJson =
JSONHelper.ToJSON(NewtonDerivative.CalculatePoints(result, 0.001d, 0.5d, -3, 3));
model.IntegralStart = startIntegral;
model.IntegralEnd = endIntegral;
model.IntegralSum = RiemannSum.CalculateSum(result, startIntegral, endIntegral);
model.TaylorPoloynoomAround = taylorAround;
model.TaylorPoloynoomNiceFormat = Taylorpolynomial.CalculateNPolynomial(result, taylorAround, taylorN).ToMathString();
model.McClairenPoloynoomNiceFormat = Taylorpolynomial.CalculateNPolynomial(result, 0, taylorN).ToMathString();
model.Request = HttpContext;
try
{
model.GausJordon = GausJordan.GetBaseMathOperatorFromList(GetPoints(points)).DeepSimplyfy()
.ToMathString();
model.GausJordonFault = false;
}
catch (Exception e)
{
model.GausJordonFault = true;
}
var json = JsonCreator.CreateFromBaseOpeator(result);
model.JsonData = JsonConvert.SerializeObject(json);
model.TaylorPossible = model.McClairenPoloynoomNiceFormat.IndexOf("NaN", StringComparison.Ordinal) >= 0 || model.TaylorPoloynoomNiceFormat.IndexOf("NaN", StringComparison.Ordinal) >= 0;
return(View(model));
}
public IActionResult Calculate(string formula)
{
if (string.IsNullOrEmpty(formula))
{
return(RedirectToAction("Index"));
}
var model = new CalculateViewModel();
var parser = StringParser.Create(formula);
var calculatedFormula = parser.GetOperator();
model.OriginalFormula = calculatedFormula.ToString();
model.Logic = calculatedFormula.ToLogicString();
model.Nandify = calculatedFormula.ToNandify().ToString();
model.HasResult = calculatedFormula.HasResult();
var json = JsonCreator.CreateFromBaseOpeator(calculatedFormula);
model.JsonData = JsonConvert.SerializeObject(json);
SemanticTableauxParser tableaux;
if (calculatedFormula.HasResult())
{
var stable = new SimplifiedTruthTableCreator(calculatedFormula);
var table = new TruthTableCreator(calculatedFormula);
var normal = new DisjunctiveNormalDecorator(table);
var simplifiedNormal = new DisjunctiveNormalDecorator(stable);
model.Normalize = normal.GetOperator().ToString();
model.NormalizeLogicFormat = normal.GetOperator().ToLogicString();
model.TruthTable = table.GetTable();
model.SimplifiedTruthTable = stable.GetTable();
model.Arguments = calculatedFormula.GetArguments();
model.SimplifiedNormalize = simplifiedNormal.GetOperator().ToString();
model.SimplifiedNormalizeLogicFormat = simplifiedNormal.GetOperator().ToLogicString();
model.Hex = table.ToHex();
}
tableaux = new SemanticTableauxParser(calculatedFormula);
model.isTautology = tableaux.IsTautology();
model.tableauxJsonData =
JsonConvert.SerializeObject(JsonCreator.CreateFromTableauxStep(tableaux.GetStep()));
return(View(model));
}
public IActionResult Calculate(CalculateViewModel model)
{
var fuel = (this.fuelsManager.GetItems() as IEnumerable <Fuel>).FirstOrDefault(f => f.FuelType.ToLower() == model.FuelType);
if (fuel != null && model.Distance > 0 && model.Consumption > 0 && model.Seats > 0)
{
model.FuelPrice = fuel.FuelPrice;
model.TotalPrice = model.Distance * (model.Consumption / 100.0M) * model.FuelPrice;
model.PricePerPerson = model.TotalPrice / model.Seats;
return(Json(model));
}
return(null);
}
public ActionResult ModelBindingInSeparateModel(CalculateViewModel model)
{
string result = "";
string firstNum = this.Request.Form["firstNum"];
string secondNum = this.Request.Form["secondNum"];
if (this.ModelState.IsValid)
{
int saveNum1 = int.Parse(firstNum);
String Op = this.Request.Form["Op"];
if (Op == "/" && secondNum == "0")
{
this.ModelState.AddModelError("secondNum", "Cant divide by Zero");
return(this.View(model));
}
int saveNum2 = int.Parse(secondNum);
if (Op == "+")
{
result = calculation.Sum(saveNum1, saveNum2) + "";
}
else if (Op == "-")
{
result = calculation.Sub(saveNum1, saveNum2) + "";
}
else if (Op == "/")
{
result = calculation.Division(saveNum1, saveNum2) + "";
}
else if (Op == "*")
{
result = calculation.Multiplication(saveNum1, saveNum2) + "";
}
var resultModel = new ColculationModel()
{
firstNum = saveNum1,
secondNum = saveNum2,
Result = result
};
return(this.View("Result", resultModel));
}
return(this.View(model));
}
public IHttpActionResult CalculateTotalAmount([FromBody] CalculateViewModel model)
{
if (_headerAuthenticator.KeyIsValid(Request))
{
if (ModelState.IsValid)
{
return(Ok(_calculator.CalculateInterest(model)));
}
else
{
return(BadRequest(ModelState));
}
}
return(Unauthorized(new AuthenticationHeaderValue("Basic", Constants.ApiKey)));
}
public IActionResult Сalculate(Credit credit)
{
if (ModelState.IsValid)
{
var vm = new CalculateViewModel
{
Credit = credit,
CreditResults = credit.StacksCredit == StacksCredit.InDay ? _calculateService.GetCreditDaysResult(credit) : _calculateService.GetCreditMounthResult(credit)
};
return(View(vm));
}
else
{
return(View(credit));
}
}
public IActionResult Calculate()
{
List <Shape> TheList = context.Shapes.ToList();
if (TheList.Count > 0)
{
CalculateViewModel calculateViewModel = new CalculateViewModel();
calculateViewModel.TheList = TheList;
return(View(calculateViewModel));
}
else
{
return(Redirect("/"));
}
}
public ActionResult ModelBindingInSeparateModel(CalculateViewModel model)
{
if (this.ModelState.IsValid)
{
if (model.Number2 == 0 && model.Operation == "/")
{
this.ModelState.AddModelError("Number2", "Division by zero is forbidden");
return(this.View(model));
}
int?result = null;
switch (model.Operation)
{
case "+":
result = calculateService.Summ(model.Number1.Value, model.Number2.Value); break;
case "-":
result = calculateService.Subtraction(model.Number1.Value, model.Number2.Value); break;
case "*":
result = calculateService.Multiplication(model.Number1.Value, model.Number2.Value); break;
case "/":
result = calculateService.Division(model.Number1.Value, model.Number2.Value); break;
}
var resultModel = new CalculateViewModel()
{
Number1 = model.Number1,
Number2 = model.Number2,
Operation = model.Operation,
ResultNumber = result
};
return(this.View("ModelBindingInSeparateModel", resultModel));
}
return(this.View(model));
}
public ActionResult Calculate(CalculateViewModel viewModel)
{
return(View(_service.DisplayPage(viewModel)));
}
public void ProcessInput(CalculateViewModel c)
{
char input = c.Input;
c.Input = '\0';
double t = char.GetNumericValue(input);
if (input != '.')
{
if (t < 0)
{
if (input == '=')
{
c.Output = "";
double result = Calculator.Calculate(c.Operand1, c.Operand2, c.Operator);
c.Output = result.ToString();
c.OperandIndex = 0;
c.Output = c.Operand1 + c.Operator + c.Operand2 + '=' + c.Output;
c.Operand1 = result.ToString();
}
if (input == 'c')
{
c.Output = "";
c.Operand1 = "";
c.Operand2 = "";
c.OperandIndex = 0;
}
if (input == '+' || input == '-' || input == '*' || input == '/' || input == '^')
{
c.Operator = input;
c.OperandIndex = 1;
c.Operand2 = "";
c.Output = input.ToString();
}
}
else
{
if (c.OperandIndex == 0)
{
if (String.IsNullOrEmpty(c.Operand2))
{
c.Operand1 += input;
c.Output = c.Operand1;
}
else
{
c.Operand1 = "";
c.Operand2 = "";
c.Operand1 += input;
c.OperandIndex = 0;
c.Output = c.Operand1;
}
}
else
{
c.Operand2 += input;
c.Output = c.Operand2;
}
}
}
else if (c.OperandIndex == 0)
{
if (String.IsNullOrEmpty(c.Operand2))
{
c.Operand1 += input;
c.Output = c.Operand1;
}
}
}
public ActionResult Calculate(CalculateViewModel c)
{
ProcessInput(c);
ModelState.Clear();
return(View("Calculate", c));
}
/// <summary>
/// Allows users to request a Calculation be performed.
/// </summary>
/// <param name="x">Dividend</param>
/// <param name="y">Divisor</param>
/// <returns>A ViewResult</returns>
public IActionResult Calculate(int x, int y)
{
var viewModel = new CalculateViewModel(x, y);
return(View(viewModel));
}
public CalculateViewModel DisplayPage(CalculateViewModel viewModel)
{
var model = new CalculateModel(viewModel, _deliveryCostCalculator, _config);
return(model.ViewModel);
}
public CalculatePage()
{
this.InitializeComponent();
CalculateViewModel = new CalculateViewModel();
}
public double Post([FromBody] CalculateViewModel calculateViewModel)
{
var result = _calculateService.Calculate(calculateViewModel.Formula, () => new { calculateViewModel.para });
return(result);
}
public HomeController()
{
_calculate = CalcualteSequence.Instance;
_calculateViewModel = new CalculateViewModel();
}
public CalculatorPage()
{
InitializeComponent();
BindingContext = new CalculateViewModel();
}
public ActionResult ManualWithSeparateHandlersConfirm()
{
String input1 = this.Request.Form["Number1"];
String input2 = this.Request.Form["Number2"];
bool error = false;
int?number1 = null;
int?number2 = null;
if (String.IsNullOrEmpty(input1))
{
this.ViewBag.Number1Null = "First number is NULL";
error = true;
}
else
{
number1 = Convert.ToInt32(input1);
}
if (String.IsNullOrEmpty(input2))
{
this.ViewBag.Number2Null = "Second number is NULL";
error = true;
}
else
{
number2 = Convert.ToInt32(input2);
}
String operation = this.Request.Form["Operation"];
if (number2 == 0 && operation == "/")
{
this.ViewBag.DividedByZero = "Division by zero";
error = true;
}
this.ViewBag.Number1 = number1;
this.ViewBag.Number2 = number2;
this.ViewBag.Operation = operation;
if (error)
{
return(this.View());
}
int result = 0;
switch (operation)
{
case "+":
result = calculateService.Summ(number1.Value, number2.Value); break;
case "-":
result = calculateService.Subtraction(number1.Value, number2.Value); break;
case "*":
result = calculateService.Multiplication(number1.Value, number2.Value); break;
case "/":
result = calculateService.Division(number1.Value, number2.Value); break;
}
var resultModel = new CalculateViewModel
{
ResultNumber = result
};
return(this.View("ManualWithSeparateHandlers", resultModel));
}
public JsonResult GetDeliveryCost(CalculateViewModel viewModel)
{
return(Json(_service.GetDeliveryCostPage(viewModel), JsonRequestBehavior.AllowGet));
}
