private void AddProcessingOrder_btn(object sender, RoutedEventArgs e)
{
int adultNumber = InputChecker.GetNumber(AdultNumber_TxtBox.Text);
int childrenNumber = InputChecker.GetNumber(ChildrenNumber_TxtBox.Text);
if (Tours_lv.SelectedItems != null && (adultNumber > 0 || childrenNumber > 0))
{
Tour selectedTour = (Tour)Tours_lv.SelectedItem;
if (selectedTour != null)
{
if (selectedTour.IsEnoughAvailableSeats(adultNumber + childrenNumber))
{
ProcessingOrder processingOrder = ProcessingOrderFactory.Create(adultNumber, childrenNumber, selectedTour);
if (processingOrder.IsOrderRegistered())
{
DialogBox.Ok("Error", "Such an order already exists.");
}
else
{
processingOrder.AddInSingleton();
selectedTour.BookSeats(adultNumber + childrenNumber);
DialogBox.Ok("Success", "Order has been recorded");
}
}
else
{
DialogBox.Ok("Error", "Snif, not enough place. Check for another");
}
}
}
else
{
DialogBox.Ok("Error", "Please, check fields");
}
}
public void ProcessingOrderClass_DefaultCountructor_ShouldInitializeObjectCorrectly()
{
// Arrange & Act
var processingOrder = new ProcessingOrder();
// Assert
Assert.That(processingOrder, Is.Not.Null);
}
public void ProcessingOrderClass_ShouldImplementIProcessingOrderInterface()
{
// Arrange & Act
var processingOrder = new ProcessingOrder();
// Assert
Assert.That(processingOrder, Is.InstanceOf <IProcessingOrder>());
}
private void DeleteOrder_Btn(object sender, RoutedEventArgs e)
{
ProcessingOrder processingOrder = (ProcessingOrder)ProcessingOrders_lv.SelectedItem;
if (processingOrder != null)
{
processingOrder.Delete();
}
ProcessingOrders_lv.Items.Refresh();
}
public string GetProcessingOrder()
{
List <OrderSummary> _lstPendingLst = new List <OrderSummary>();
ProcessingOrder _processingOrder = new ProcessingOrder();
_lstPendingLst = _processingOrder.GetAllProcessingOrder();
var jsonss = Newtonsoft.Json.JsonConvert.SerializeObject(_lstPendingLst);
return(jsonss);
}
public void ProcessingOrderClass_AllProperties_ShouldExists()
{
// Arrange & Act
var processingOrder = new ProcessingOrder();
// Assert
Assert.That(processingOrder, Has.Property("SelectedCoffeeType"));
Assert.That(processingOrder, Has.Property("SelectedCoffeeSize"));
Assert.That(processingOrder, Has.Property("SelectedCoffeeCodimentsList"));
}
public void ProcessingOrderClass_SelectedCoffeeSizeProperty_ShouldReturnCorrectValue()
{
// Arrange
var coffeeSize = "Grande";
var processingOrder = new ProcessingOrder();
// Act
processingOrder.SelectedCoffeeSize = coffeeSize;
// Assert
Assert.That(processingOrder.SelectedCoffeeSize, Is.SameAs(coffeeSize));
}
private void RemoveChild_Btn(object sender, RoutedEventArgs e)
{
ProcessingOrder processingOrder = (ProcessingOrder)ProcessingOrders_lv.SelectedItem;
if (processingOrder != null)
{
if (processingOrder.CanRemoveChild())
{
processingOrder.RemoveChild();
}
}
ProcessingOrders_lv.Items.Refresh();
}
public static ProcessingOrder Create(int adults, int children, Tour tour)
{
ProcessingOrder processingOrder = new ProcessingOrder();
processingOrder.AdultNumber = adults;
processingOrder.ChildrenNumber = children;
processingOrder.Tour = tour;
Price price = Price.GetPrice();
double amount = adults * price.AdultPrice + children * price.ChildPrice;
processingOrder.TotalAmount = amount;
return(processingOrder);
}
public void ProcessingOrderClass_SelectedCoffeeCodimentsListProperty_ShouldReturnCorrectValue()
{
// Arrange & Act
var condimentsList = new List <string> {
"Milk", "Honey"
};
var processingOrder = new ProcessingOrder();
// Act
processingOrder.SelectedCoffeeCodimentsList = condimentsList;
// Assert
Assert.That(processingOrder.SelectedCoffeeCodimentsList, Is.SameAs(condimentsList));
}
public IEnumerable <T> CollectOperands(IEditEnumerator <T> itr, ProcessingOrder direction = ProcessingOrder.LeftToRight)
{
while (itr.Move((int)direction))
{
Member member = Classify(itr.Current);
// Stop if we get an operator or a bracket indicating the end of expression (which bracket depends on the processing direction)
if (member == Member.Operator || (int)direction == (int)member)
{
break;
}
yield return(ParseOperand(itr));
itr.Move(-(int)direction);
itr.Remove((int)direction);
}
}
private void AddChild_Btn(object sender, RoutedEventArgs e)
{
ProcessingOrder processingOrder = (ProcessingOrder)ProcessingOrders_lv.SelectedItem;
if (processingOrder != null)
{
if (processingOrder.CanAddPerson())
{
processingOrder.AddChild();
}
else
{
DialogBox.Ok("Error", "Not enough seats available");
}
}
ProcessingOrders_lv.Items.Refresh();
}
private void ConfirmPayment(object sender, RoutedEventArgs e)
{
List <String> fields = new List <String>();
fields.Add(NumCreditCard_TextBox.Text);
fields.Add(CCVCreditCard_TextBox.Text);
if (InputChecker.AreAllFieldsComplete(fields))
{
ProcessingOrder.PaymentConfirmed();
DialogBox.Ok("Success", "Great business with you, master chief");
}
else
{
DialogBox.Ok("Error", "Correctly fill the fields so i can buy a new bike.");
}
}
private T Parse(IEditEnumerator <T> start, ProcessingOrder direction = ProcessingOrder.LeftToRight)
{
SortedDictionary <int, ProcessingOrder> order = new SortedDictionary <int, ProcessingOrder>();
IEditEnumerator <T> end = start.Copy();
int count = 0;
#if DEBUG
string parsing = "";
while (end.Move((int)direction))
{
if (direction == ProcessingOrder.LeftToRight)
{
parsing += end.Current + "|";
}
else
{
parsing = end.Current + "|" + parsing;
}
}
Print.Log("parsing section |" + parsing);
Print.Log("start is " + start.Current + " and end is " + end.Current);
end = start.Copy();
#endif
// Initial pass over the input to figure out:
// Where the beginning and end are (match parentheses)
// What operators we should look for (so we can skip iterating empty tiers)
// Also delete anything that's supposed to be ignored
while (end.Move((int)direction))
{
if (!(end.Current is T))
{
continue;
}
T current = (T)end.Current;
Member member = Classify(current);
// This is the "close" bracket for the direction we're moving
if ((int)direction == (int)member)
{
// This is the end of the expression we're working on
if (count == 0)
{
break;
}
else
{
count--;
}
}
// This is the "open" bracket for the direction we're moving
else if ((int)direction == -(int)member)
{
count++;
}
else if (Ignore.Contains(current))
{
end.Move(-1);
end.Remove(1);
}
// Keep track of what operators we find so we can skip them later
else if (member == Member.Operator)
{
Tuple <Operator <T>, int> temp = Operations[current];
order[temp.Item2] = temp.Item1.Order;
}
}
foreach (KeyValuePair <int, ProcessingOrder> kvp in order)
{
IEditEnumerator <T> itr = kvp.Value == ProcessingOrder.LeftToRight ^ direction == ProcessingOrder.LeftToRight ? end.Copy() : start.Copy();
while (itr.Move((int)kvp.Value) && !itr.Equals(start) && !itr.Equals(end))
{
if (!(itr.Current is T))
{
continue;
}
Tuple <Operator <T>, int> tuple;
if (Operations.TryGetValue((T)itr.Current, out tuple) && kvp.Key == tuple.Item2)
{
Print.Log("doing operation", itr.Current);
Operator <T> operation = tuple.Item1;
IEditEnumerator <T>[] operandItrs = new IEditEnumerator <T> [operation.Targets.Length];
for (int j = 0; j < operation.Targets.Length; j++)
{
//operation.Targets[j](operandItrs[j] = itr.Copy());
}
T[] operands = new T[operandItrs.Length];
for (int j = 0; j < operandItrs.Length; j++)
{
Print.Log("\t" + operandItrs[j].Current);
operands[j] = ParseOperand(operandItrs[j]);
operandItrs[j].Remove(0);
}
itr.Add(0, operation.Operate(operands));
}
}
}
#if DEBUG
Print.Log("done");
IEditEnumerator <T> printer = start.Copy();
while (printer.MoveNext())
{
Print.Log("\t" + printer.Current);
}
#endif
IEditEnumerator <T> juxtapose = start.Copy();
T result = Juxtapose(CollectOperands(juxtapose, direction));
juxtapose.Remove(0);
return(result);
}
public Operator(FunctionWithVariableParamterCount <T> operate, ProcessingOrder order, params Action <IEditEnumerator <T> >[] targets) : base(operate, order, targets)
{
}
public BinaryOperator(Func <T, T, T> func, Action <IEditEnumerator <T> > previous, Action <IEditEnumerator <T> > next, ProcessingOrder order = ProcessingOrder.LeftToRight) : base((o) => func(o[0], o[1]), order, previous, next)
{
}
public Element()
{
this.orderField = 0;
this.processingOrderField = ProcessingOrder.Document;
}
public Operator(FunctionWithVariableParamterCount <T> operateFunc, params Action <IEditEnumerator <T> >[] targets)
{
Operate = operateFunc;
Targets = targets;
Order = ProcessingOrder.LeftToRight;
}
