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; }