/// <summary>
/// Returns the domain entity for a view model.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
private Calculation GetCalculationFromViewModel(CalculationViewModel model)
{
var calculation = new Calculation
{
Id = model.Id ?? 0,
UserId = UserId,
Width = model.Width,
Height = model.Height,
BorderX = model.BorderX,
BorderY = model.BorderY,
DrillingPointDistanceX = model.DrillingPointDistanceX,
DrillingPointDistanceY = model.DrillingPointDistanceY,
SealingSlabDiameter = model.SealingSlabDiameter,
Depth = model.Depth,
PixelsPerMeter = model.PixelsPerMeter,
StandardDerivationOffset = model.StandardDerivationOffset,
StandardDerivationRadius = model.StandardDerivationRadius,
StandardDerivationDrillingPoint = model.StandardDerivationDrillingPoint,
TimeStamp = DateTime.Now,
Iterations = model.Iterations,
WaterLevelDifference = model.WaterLevelDifference,
SealingSlabThickness = model.SealingSlabThickness,
PermeabilityOfSoleWithoutUnsetArea = model.PermeabilityOfSoleWithoutUnsetArea,
PermeabilityOfSoleAtUnsetArea = model.PermeabilityOfSoleAtUnsetArea,
ResidualWaterResult = model.ResidualWaterResult
};
return(calculation);
}
/// <summary>
/// Returns the derivation preview image file for a view model.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public FileContentResult DerivationPreviewImage(CalculationViewModel model)
{
var calculation = GetCalculationFromViewModel(model);
var image = new CalculationService().GetDerivationPreviewImage(calculation);
return(File(GetBytesFromImage(image), MimeMapping.GetMimeMapping(previewFileName), previewFileName));
}
public PartialViewResult Execute(CalculationViewModel model)
{
if (ModelState.IsValid)
{
bool status = ExecuteActionWithValidation(() =>
{
var calculation = GetCalculationFromViewModel(model);
var calculationService = new CalculationService();
calculationService.Execute(calculation);
// Rebind View
model = GetViewModelFromCalculation(calculationService.GetViewById(calculation.Id));
SetSuccessMessage("The calculation is enqueued.");
});
if (status)
{
// Clear ModelState otherwise Id will stay 0
ModelState.Clear();
return(PartialView("Form", model));
}
}
return(PartialView("Form"));
}
public PoissonPage()
{
InitializeComponent();
var item = new PoissonModel();
BindingContext = _viewModel = new CalculationViewModel(item);
}
public MainWindow()
{
InitializeComponent();
ViewModel = new CalculationViewModel();
this.DataContext = ViewModel;
}
public static void ExportEnergyLabel(PackagedSolution packaged)
{
if (packaged.EnergyLabel.Count <= 0)
{
return;
}
var fixedDoc = new FixedDocument();
var v = new LabelLayout();
var vm = new LabelExportViewModel(packaged);
fixedDoc.Pages.Add(CreatePageContent(v, vm));
var calculationLayout = new CalculationLayout();
var calculationViewModel = new CalculationViewModel(packaged.EnergyLabel);
calculationViewModel.Setup();
fixedDoc.Pages.Add(CreatePageContent(calculationLayout, calculationViewModel));
if (packaged.EnergyLabel.Count > 1)
{
calculationLayout = new CalculationLayout();
calculationViewModel = new CalculationViewModel(packaged.EnergyLabel);
calculationViewModel.SetupSpecialPage();
fixedDoc.Pages.Add(CreatePageContent(calculationLayout, calculationViewModel));
}
IDocumentPaginatorSource dps = fixedDoc;
RunSaveDialog(fixedDoc.DocumentPaginator, packaged.Name);
}
private void btn_Calculation_Click(object sender, EventArgs e)
{
//создаем модель и заполняем её аргументами
var model = new CalculationViewModel
{
Argument1 = this.viewUI.GetArgument1(),
Argument2 = this.viewUI.GetArgument2(),
SelectedOperationType = this.viewUI.GetOperationType()
};
string operationResult = string.Empty;
try
{
//получаем результат операции от презентера
operationResult = this.presenter.Calculation(model);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
//отображаем результат операции
this.viewUI.SetOperationResult(operationResult);
}
public ActionResult Calculate(CalculationViewModel vm)
{
// 入力チェック
if (vm.LeftNum == string.Empty || vm.RightNum == string.Empty)
{
return(View());
}
// ViewModel -> Model
var calculator = new Calculator();
calculator.LeftNum = int.Parse(vm.LeftNum);
calculator.RightNum = int.Parse(vm.RightNum);
calculator.Operator = vm.SelectedOperator;
// 計算
var service = new CalculationService();
var calculatedValue = service.calculate(calculator);
// Model -> ViewModel
var resultVM = new CalculationResultViewModel();
resultVM.CalculatedValue = calculatedValue.ToString();
return(View("Result", resultVM));
}
public Calculation()
{
InitializeComponent();
Loaded += (s, e) =>
{
DataContext = new CalculationViewModel();
};
}
public ValuePage()
{
InitializeComponent();
var item = new ValueBetModel();
BindingContext = _viewModel = new CalculationViewModel(item);
}
public List <LoanViewModel> Calculation(CalculationViewModel loan)
{
if (loan == null)
{
return(null);
}
return(_mortgageService.LoanCalculation(loan.LoanAmount, loan.InterestRate, loan.Years, loan.LoanType));
}
public ProbabilityPage()
{
InitializeComponent();
var item = new ProbabilityBetModel();
BindingContext = _viewModel = new CalculationViewModel(item);
}
/// <summary>
/// Returns the details form for an existing calculation by its id.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public ActionResult Details(int id)
{
var calculation = new CalculationService().GetViewById(id);
CalculationViewModel calculationModel = GetViewModelFromCalculation(calculation);
return(View(calculationModel));
}
public ViewWindow()
{
InitializeComponent();
var intervals = (RangeConfiguration)ConfigurationManager.GetSection("RangeConfiguration");
_viewModel = new CalculationViewModel(intervals.Ranges);
_threadSafeVM = new SynchronizedNotifyPropertyChanged <CalculationViewModel>(_viewModel, this);
}
public void GivenInputHasConsecutiveOperatorsErrorIsThrownAndNoResultGiven()
{
var viewModel = new CalculationViewModel()
{
Expression = "12+-67"
};
var errors = viewModel.Validate();
Assert.IsNotEmpty(errors);
}
public void GivenValidInputErrorIsNotThrownAndResultIsGiven(string expressionInput)
{
var viewModel = new CalculationViewModel()
{
Expression = expressionInput
};
var errors = viewModel.Validate();
Assert.IsEmpty(errors);
}
public void GivenAlphabeticInputErrorIsThrownAndNoResultGiven()
{
var viewModel = new CalculationViewModel()
{
Expression = "House"
};
var errors = viewModel.Validate();
Assert.IsNotEmpty(errors);
}
public void GivenBracketsInputErrorIsThrownAndNoResultGiven()
{
var viewModel = new CalculationViewModel()
{
Expression = "2*(2+8)"
};
var errors = viewModel.Validate();
Assert.IsNotEmpty(errors);
}
public void GivenDecimalInputErrorIsThrownAndNoResultGiven()
{
var viewModel = new CalculationViewModel()
{
Expression = "1.3+4"
};
var errors = viewModel.Validate();
Assert.IsNotEmpty(errors);
}
public void GivenInputBeginsWithOperatorErrorIsThrownAndNoResultGiven()
{
var viewModel = new CalculationViewModel()
{
Expression = "+2*2+8"
};
var errors = viewModel.Validate();
Assert.IsNotEmpty(errors);
}
/// <summary>
/// Returns the underlying price based on the given parameters
/// </summary>
/// <param name="model">The calculation model</param>
/// <returns></returns>
public JsonResult GetStatistics(CalculationViewModel model)
{
var result =
Mapper.Map <CalculationResultViewModel>(
_priceCalculatorService.CalculatePotentialEarnings(Mapper.Map <ICalculation>(model)));
return(Json(new
{
Result = RenderPartialViewToString("ViewModelCalculationResult", result)
}));
}
public void Initialize()
{
_mortgageServiceMock = new Mock <IMortgageService>();
_objController = new MortgageApiController(_mortgageServiceMock.Object);
_listMortgages = new List <Mortgage>()
{
new Mortgage()
{
MortgageId = 1, Name = "Test", MortgageType = MortgageType.Fixed, InterestRepayment = InterestRepayment.InterestOnly, EffectiveStartDate = DateTime.Now.AddDays(-365), EffectiveEndDate = DateTime.Now, TermsInMonths = 12, CancellationFee = 0, EstablishmentFee = 1000, InterestRate = 13.5M
},
new Mortgage()
{
MortgageId = 2, Name = "TestOne", MortgageType = MortgageType.Variable, InterestRepayment = InterestRepayment.InterestOnly, EffectiveStartDate = DateTime.Now.AddDays(-365), EffectiveEndDate = DateTime.Now, TermsInMonths = 12, CancellationFee = 0, EstablishmentFee = 1000, InterestRate = 13.5M
},
};
_listLoan = new List <LoanViewModel>()
{
new LoanViewModel()
{
PrincipalAmount = 200000, EMIAmount = 35000, EMIDate = DateTime.Now.AddDays(-30), InterestAmount = 13000, TotalAmount = 35000
},
new LoanViewModel()
{
PrincipalAmount = 200000, EMIAmount = 33000, EMIDate = DateTime.Now, InterestAmount = 13000, TotalAmount = 35000
}
};
calc = new CalculationViewModel()
{
LoanAmount = 200000, InterestRate = 13.5, LoanType = "Variable", Years = 10
};
_mortgage = new Mortgage()
{
MortgageId = 1,
Name = "Test",
MortgageType = MortgageType.Fixed,
InterestRepayment = InterestRepayment.InterestOnly,
EffectiveStartDate = DateTime.Now.AddDays(-365),
EffectiveEndDate = DateTime.Now,
TermsInMonths = 12,
CancellationFee = 0,
EstablishmentFee = 1000,
InterestRate = 13.5M
};
}
public ActionResult Delete(Guid id, CalculationViewModel model)
{
try
{
_commandDispatcher.Execute(new CalculationRemoveCommand(id, model.OriginalVersion));
return(RedirectToAction("Index"));
}
catch (DomainValidationException validationException)
{
ModelState.AddModelError(validationException.Property, validationException.Message);
}
return(View(model));
}
/// <summary>
/// Вычисление
/// </summary>
/// <param name="model">ViewModel для presenter</param>
/// <returns>результат операции (строка)</returns>
public string Calculation(CalculationViewModel model)
{
//проверили и типизировали данные из модели
var argument1 = Converter.IntFromString(model.Argument1,
"Недопустимое значение первого аргумента.");
var argument2 = Converter.IntFromString(model.Argument2,
"Недопустимое значение второго аргумента.");
var operationType = Converter.OperationTypeFromString(model.SelectedOperationType,
"Не выбран тип операции.");
//вызвали службу и заполнили модель результатом операции
decimal operationResult;
switch (operationType)
{
//Сложение
case OperationTypes.Addition:
operationResult = calculationService.Addition(argument1, argument2);
break;
//Вычитание
case OperationTypes.Subtraction:
operationResult = calculationService.Subtraction(argument1, argument2);
break;
//Умножение
case OperationTypes.Multiplication:
operationResult = calculationService.Multiplication(argument1, argument2);
break;
//Деление
case OperationTypes.Division:
operationResult = calculationService.Division(argument1, argument2);
break;
default:
operationResult = 0;
throw new Exception("Не удалось получить результат");
}
//Сохранение
storageService.Save(argument1,
argument2,
operationResult,
operationType);
//возвращаем результат операции
return(operationResult.ToString());
}
public ActionResult Edit(Guid id, CalculationViewModel model)
{
try
{
_commandDispatcher.Execute(new CalculationChangeCommand(id, model.OriginalVersion, model.Name, model.Wkn,
model.Multiplier, model.StrikePrice, model.Underlying, model.InitialSl,
model.InitialTp, model.PricePerUnit, model.OrderCosts, model.Description, model.Units, model.IsLong));
return(RedirectToAction("Index"));
}
catch (DomainValidationException validationException)
{
ModelState.AddModelError(validationException.Property, validationException.Message);
}
return(View(model));
}
public ActionResult CalculationForm(CalculationViewModel model)
{
if (ModelState.IsValid)
{
try
{
//Передаем ViewModel в презентер и получаем измененную ViewModel
model.OperationResult = presenter.Calculation(model);
}
catch (Exception e)
{
//выводим сообщение об ошибке
return(RedirectToAction("ShowError", "Error", e.Message));
}
}
return(View(model));
}
public IActionResult PerformCalculation(CalculationViewModel model)
{
var errors = model.Validate();
if (errors.Count > 0)
{
foreach (var error in errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
return(View("Index", model));
}
model.Result = CalculationHelper.GetExpressionResult(model.Expression);
return(View("Index", model));
}
public void InvokeCalculationMethod_WithCorrectModel_WithOperationType_Multiplication_ExpectedCorrectModel_WithCorrectOperationResult()
{
//arrange
//модель, передаваемая в качестве аргумента
var model = new CalculationViewModel
{
Argument1 = "1",
Argument2 = "2",
SelectedOperationType = "Умножение"
};
//act
string operationResult = presenter.Calculation(model);
//assert
Assert.AreEqual("2", operationResult);
}
public void DivideCommandTest()
{
// Arrange
CalculationViewModel target = new CalculationViewModel();
int firstNumber = 4;
int secondNumber = 2;
int expected = 2;
int actual;
target.FirstNumber = firstNumber;
target.SecondNumber = secondNumber;
// Act
target.DivideCommand.Execute(null);
actual = target.Result;
// Assert
Assert.AreEqual(expected, actual);
}
public PartialViewResult DerivationPreview(CalculationViewModel model)
{
if (ModelState.IsValid)
{
bool status = ExecuteActionWithValidation(() =>
{
model.HasDerivationPreview = true;
SetSuccessMessage("Parameters are valid for preview.");
});
if (status)
{
return(PartialView("Form", model));
}
}
return(PartialView("Form"));
}
public PartialViewResult Cancel(CalculationViewModel model)
{
if (ModelState.IsValid)
{
bool status = ExecuteActionWithValidation(() =>
{
new CalculationService().Cancel(model.Id.Value);
SetSuccessMessage("The calculation will be cancelled.");
});
if (status)
{
return(PartialView("Form", model));
}
}
return(PartialView("Form"));
}
