protected internal override void Sub(CalculatorContext context, Stack <string> stack)
{
Calculator ctxt = context.Owner;
if (stack.Count >= 2)
{
CalculatorState endState = context.State;
context.ClearState();
try
{
ctxt.Sub();
}
finally
{
context.State = endState;
}
}
else
{
context.State.Exit(context);
context.State = Map1.ErrorTuple;
context.State.Entry(context);
}
return;
}
public void EnteringSeveralDigitsDisplaysTheWholeNumber()
{
sut = sut.EnterDigit('2');
sut = sut.EnterDigit('3');
Assert.AreEqual("23", sut.Display);
}
private void buttonEqual_Click(object sender, EventArgs e)
{
if (currentState == CalculatorState.secondNumberInput && txtResult.Text != "")
{
double result = 0;
secondNumber = double.Parse(txtResult.Text);
if (currentOperation == OperationState.add)
{
result = firstNumber + secondNumber;
}
else if (currentOperation == OperationState.sub)
{
result = firstNumber - secondNumber;
}
else if (currentOperation == OperationState.mul)
{
result = firstNumber * secondNumber;
}
else if (currentOperation == OperationState.div)
{
result = firstNumber / secondNumber;
}
txtResult.Text = result.ToString();
currentState = CalculatorState.firstNumberInput;
}
}
private void buttonCancel_Click(object sender, EventArgs e)
{
txtResult.Text = "";
firstNumber = 0;
secondNumber = 0;
currentState = CalculatorState.firstNumberInput;
}
private void allOperationsButtons_click(object sender, EventArgs e)
{
if (txtResult.Text != "")
{
firstNumber = double.Parse(txtResult.Text);
txtResult.Text = "";
currentState = CalculatorState.secondNumberInput;
Button currentButton = (Button)sender;
if (currentButton.Name == "buttonPlus")
{
currentOperation = OperationState.add;
}
else if (currentButton.Name == "buttonMinus")
{
currentOperation = OperationState.sub;
}
else if (currentButton.Name == "buttonMultiply")
{
currentOperation = OperationState.mul;
}
else if (currentButton.Name == "buttonDivision")
{
currentOperation = OperationState.div;
}
}
}
public CalculatorViewModel(INavigationService navigation)
{
_state = CalculatorState.PopulatingFirstNumber;
_currentOperation = Operation.None;
_navigation = navigation;
SubscribeToMessage();
}
public override void DoDemo()
{
Console.WriteLine("===================[Begin Demo: " + DemoTitle + "]=====================");
TestFixture.SetUp();
TestFixture.RunTests();
TestFixture.TearDown();
var state = new CalculatorState();
var proc = new CalculatorProcessor(state);
var disp = new List <CalculatorDisplay>
{
new CalculatorDisplay(),
new CalculatorDisplay(),
new CalculatorDisplay(),
};
var calc = new Calculator(proc, disp.ToArray());
Console.WriteLine("Running calculator with " + disp.Count + " displays");
Console.WriteLine("Adding 10 ...");
calc.Add(10);
Console.WriteLine("Substracting 5 ...");
calc.Substract(5);
Console.WriteLine("===================[End Demo: " + DemoTitle + "]======================");
}
private void Calculate()
{
var first = decimal.Parse(_firstNumber);
var second = decimal.Parse(_secondNumber);
decimal result = 0;
switch (_currentOperation)
{
case Operation.Add:
result = first + second;
break;
case Operation.Subtract:
result = first - second;
break;
case Operation.Divide:
result = first / second;
break;
case Operation.Multiply:
result = first * second;
break;
default:
break;
}
DisplayText = result.ToString();
_calculatorHistory.Add($"{_firstNumber} {GetOperationString()} {_secondNumber} = {result}");
_currentOperation = Operation.None;
_state = CalculatorState.PopulatingFirstNumber;
_firstNumber = string.Empty;
_secondNumber = string.Empty;
}
private void NumberButton_Clicked(object sender, EventArgs e)
{
if (!(sender is Button button))
{
return;
}
int.TryParse(button.Text, out int number);
if (State == CalculatorState.Initial)
{
ResultLabel.Text = string.Empty;
State = CalculatorState.FistNumber;
}
else if (State == CalculatorState.SecondNumber && ResultLabel.Text == "0")
{
ResultLabel.Text = string.Empty;
}
ResultLabel.Text += number;
var colors = new string[] { "#FFA500", "#CCFF55", "#AA3399" };
var random = new Random();
var index = random.Next(3);
var color = colors[index];
Resources["OperatorColor"] = Color.FromHex(color);
}
private void ClearButton_Clicked(object sender, EventArgs e)
{
firstNumber = 0;
opr = string.Empty;
State = CalculatorState.Initial;
ResultLabel.Text = "";
}
public void EnteringAnOperatorChangesTheStateToPostOperator()
{
sut = sut.EnterDigit('2');
sut = sut.EnterOperator(new PlusOperator());
Assert.IsInstanceOfType(sut, typeof(PostOperatorState));
}
public void EnteringTheEqualSignDisplaysTheResult()
{
sut = sut.EnterDigit('3');
sut = sut.EnterDigit('3');
sut = sut.EnterEqual();
Assert.AreEqual("55", sut.Display);
}
public decimal Multiply(decimal value)
{
if (Value == 0 && _state == CalculatorState.Cleared)
{
_state = CalculatorState.Active;
return(Value = value);
}
return(Value *= value);
}
public void EnteringANewOperatorFollowedByADigitDisplaysTheDigit()
{
sut = sut.EnterDigit('3');
sut = sut.EnterDigit('3');
sut = sut.EnterOperator(new PlusOperator());
sut = sut.EnterDigit('2');
Assert.AreEqual("2", sut.Display);
}
public decimal Divide(decimal value)
{
if (Value == 0 && _state == CalculatorState.Cleared)
{
_state = CalculatorState.Active;
return(Value = value);
}
return(Value /= value);
}
private void setRunningState()
{
lock (operationLock)
{
if (state == CalculatorState.Running)
{
throw new CalculationInvalidStateOperationException("Calculation", "Running", "Run");
}
state = CalculatorState.Running;
}
}
public void FurtherOperatorsExecuteThePreviousCalculation()
{
sut = sut.EnterDigit('3');
sut = sut.EnterDigit('3');
sut = sut.EnterOperator(new PlusOperator());
sut = sut.EnterDigit('2');
sut = sut.EnterDigit('2');
sut = sut.EnterEqual();
Assert.AreEqual("77", sut.Display);
}
private void PerformOperation(Operation operation)
{
if (operation == Operation.Equal &&
!string.IsNullOrWhiteSpace(_firstNumber) &&
!string.IsNullOrWhiteSpace(_secondNumber))
{
Calculate();
return;
}
_currentOperation = operation;
DisplayText = string.Empty;
_state = CalculatorState.PopulatingSecondNumber;
}
public override void RunTests()
{
var state = new CalculatorState();
var proc = new CalculatorProcessor(state);
var calc = new Calculator(proc, _displays.Select(m => m.Object).ToArray());
calc.Add(10);
calc.Substract(5);
foreach (var disp in _displays)
{
disp.VerifyAll();
}
}
private void OperatorButton_Clicked(object sender, EventArgs e)
{
if (!(sender is Button button))
{
return;
}
int.TryParse(ResultLabel.Text, out int number);
if (State == CalculatorState.FistNumber)
{
firstNumber = number;
State = CalculatorState.SecondNumber;
opr = button.Text;
ResultLabel.Text = "";
}
}
protected internal override void ClrAll(CalculatorContext context, Stack <string> stack)
{
Calculator ctxt = context.Owner;
CalculatorState endState = context.State;
context.ClearState();
try
{
ctxt.ClrAll();
}
finally
{
context.State = endState;
}
return;
}
private void CalculateButton_Clicked(object sender, EventArgs e)
{
if (State != CalculatorState.SecondNumber)
{
return;
}
int.TryParse(ResultLabel.Text, out int secondNumber);
int result;
switch (opr)
{
case "+":
result = firstNumber + secondNumber;
break;
case "-":
result = firstNumber - secondNumber;
break;
case "x":
result = firstNumber * secondNumber;
break;
case "/":
result = firstNumber / secondNumber;
break;
default:
result = 0;
break;
}
ResultLabel.Text = result.ToString();
firstNumber = result;
opr = "";
State = CalculatorState.FistNumber;
}
public CalculatorWrongStateActionException(CalculatorState currentState, CalculatorState targetState, Calculator.Action action)
{
CurrentState = currentState;
TargetState = targetState;
Action = action;
}
public decimal Subtract(decimal value)
{
_state = CalculatorState.Active;
return(Value -= value);
}
public decimal Add(decimal value)
{
_state = CalculatorState.Active;
return(Value += value);
}
public CalculatorStateEventArgs(Calculator calculator, CalculatorState stage)
{
Calculator = calculator;
State = stage;
}
public CalculatorModel()
{
Display = "0";
calculatorState = CalculatorState.START;
}
public void EnteringADigitDisplaysThatDigit()
{
sut = sut.EnterDigit('2');
Assert.AreEqual("2", sut.Display);
}
private void start(Calculation calculation, bool doResume)
{
long totalCalcOperationCount = 0;
long preCalcOperationDoneCount = 0;
calculatorSession = new CalculatorSession {
PathNo = 1
};
if (doResume)
{
var calcResult = calculation.CalculationResult;
foreach (string s in calcResult.Messages)
{
messages.Add(s);
}
messages.Add("=====================================================");
totalCalcOperationCount = calcResult.TotalEmployeesCount;
preCalcOperationDoneCount = calcResult.EmployeesCalculatedCount;
progress.SetProgress(totalCalcOperationCount, preCalcOperationDoneCount);
if (calcResult.LastCalculatedPath.HasValue)
{
progress.SetLastCalculatedEmployee(calcResult.LastCalculatedEmployeeId, calcResult.LastCalculatedPath.Value);
calculatorSession.PathNo = calcResult.LastCalculatedPath.Value;
}
var engine = calculatorEngineFactory.Create();
try
{
calculatorSession.AddCalculationPoints(engine.GetCalculationPiontBy(calculation.Id));
}
finally
{
calculatorEngineFactory.Release(engine);
}
}
Policy policy = null;
messages.Add(DateTime.Now + "شروع محاسبه ");
try
{
startTrigger.Set();
CalculationCompletedSub = new DelegateHandler <CalculationCompleted>(e =>
{
var engine = calculatorEngineFactory.Create();
try
{
engine.AddUpdateCalculationPoint(calculatorSession.CalculationPoints);
engine.UpdateCalculationResult(calculation, progress, this, messages);
}
finally
{
calculatorEngineFactory.Release(engine);
}
});
publisher.RegisterHandler(CalculationCompletedSub);
rulsCompiledSub = new DelegateHandler <RulesCompiled>(e =>
{
if (!doResume)
{
Task.Factory.StartNew(() =>
{
var engine = calculatorEngineFactory.Create();
try
{
engine.UpdateCompileResult(calculation.Id, e.CompileResult.LibraryText, e.Rules);
}
finally
{
calculatorEngineFactory.Release(engine);
}
messages.Add(DateTime.Now + " قوانین کامپایل شدند");
});
}
});
publisher.RegisterHandler(rulsCompiledSub);
publisher.RegisterHandler <JobIndexPointsReady>(jobIndexPointPersister);
publisher.RegisterHandler <CalculationExceptionReady>(calculationExceptionPersister);
publisher.RegisterHandler <CalculationCompleted>(jobIndexPointPersister);
publisher.RegisterHandler <CalculationCompleted>(calculationExceptionPersister);
publisher.RegisterHandler <CalculationForPathCompleted>(jobIndexPointPersister);
publisher.RegisterHandler <PathPersisteCompleted>(this);
Dictionary <int, IList <Employee> > employeesWithPath;
Period period;
fetchPolicyAndEmployees(calculation, doResume, calculatorSession.PathNo, out policy, out employeesWithPath, out period);
deleteCalculationException(calculation);
long currentCalcOperationCount = 0;
foreach (var employees in employeesWithPath)
{
currentCalcOperationCount = currentCalcOperationCount + employees.Value.Count();
}
if (!doResume)
{
totalCalcOperationCount = currentCalcOperationCount;
progress.SetProgress(totalCalcOperationCount, 0);
}
messages.Add(DateTime.Now + " تعداد " + currentCalcOperationCount + " عملیات محاسبه برای " + calculation.EmployeeCount + " کارمند آماده می باشد");
var currentCalcOperationDoneCount = preCalcOperationDoneCount;
var pathCount = employeesWithPath.Count();
foreach (var emlpoyees in employeesWithPath)
{
calculatorSession.PathNo = emlpoyees.Key;
foreach (var employee in emlpoyees.Value)
{
try
{
if (doStop || doPause)
{
break;
}
var pointsHolder = calculateIndices(calculation, policy, period, employee, calculatorSession);
currentCalcOperationDoneCount++;
progress.SetProgress(totalCalcOperationCount, currentCalcOperationDoneCount);
addOrUpdateCalculationPoints(pointsHolder.CalculationPoints);
publisher.Publish(new JobIndexPointsReady(pointsHolder, calculation.Id, employee.Id, calculatorSession.PathNo));
progress.SetLastCalculatedEmployee(employee.Id, calculatorSession.PathNo);
}
catch (Exception ex)
{
publisher.Publish(new CalculationExceptionReady(calculation.Id, employee.Id, calculatorSession.PathNo, ex));
calculatorSession.HasEmployeeCalculationFailed = true;
messages.Add("*** خطا در محاسبه شاخص های کارمند " + employee.Id.EmployeeNo + " **** ");
var logServiceMngt = LogServiceFactory.Create();
try
{
var logService = logServiceMngt.GetService();
logService.AddEventLog("JobIndexPointCalculator_EmpId:" + employee.Id.EmployeeNo,
LogLevel.Error,
null, this.GetType().Name, "start", ex.Message, ex.StackTrace);
logService.AddExceptionLog(ex);
}
finally
{
LogServiceFactory.Release(logServiceMngt);
}
}
}
if (pathCount > calculatorSession.PathNo)
{
publisher.Publish(new CalculationForPathCompleted());
pathPersisterTrigger.WaitOne();
}
if (calculatorSession.HasEmployeeCalculationFailed)
{
break;
}
}
messages.Add(DateTime.Now + " تعداد " + currentCalcOperationDoneCount + " عملیات محاسبه انجام شد");
if (!(doStop || doPause))
{
publisher.Publish(new CalculationCompleted());
}
else if (doStop)
{
messages.Add(DateTime.Now + " لغو محاسبه.");
}
else if (doPause)
{
messages.Add(DateTime.Now + " وقفه در محاسبه.");
}
if (doPause || doStop)
{
var engine = calculatorEngineFactory.Create();
try
{
engine.AddUpdateCalculationPoint(calculatorSession.CalculationPoints);
}
finally
{
calculatorEngineFactory.Release(engine);
}
}
pauseTrigger.Set();
}
catch (Exception e)
{
startTrigger.Set();
calculatorSession.HasEmployeeCalculationFailed = true;
messages.Add(DateTime.Now + "در آماده سازی محاسبه با مشکل مواجه شده است");
publisher.Publish(new CalculationCompleted());
}
finally
{
state = CalculatorState.Completed;
if (policy != null)
{
policy.Dispose();
}
}
}
public void Clear()
{
Value = 0;
_state = CalculatorState.Cleared;
}
public void SetUp()
{
sut = new PostOperatorState("22", new PlusOperator());
}
