public async Task CanCloseTabWithTip(Guid tabId, int tableNumber, MenuItem[] menuItemsToOrder)
{
// Arrange
await _helper.AddMenuItems(menuItemsToOrder);
await _helper.OpenTabOnTable(tabId, tableNumber);
await _helper.ServeMenuItems(tabId, menuItemsToOrder);
var expectedTipAmount = 100;
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = menuItemsToOrder.Sum(i => i.Price) + expectedTipAmount
};
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
await _helper.AssertTabExists(
closeTabCommand.TabId,
t => t.IsOpen == false &&
t.TipValue == expectedTipAmount);
}
public Task CloseTabShouldReturnProperHypermediaLinks(Guid tabId, MenuItem[] menuItems, Fixture fixture) =>
_apiHelper.InTheContextOfAWaiter(
waiter => async httpClient =>
{
// Arrange
await _tabHelper.AddMenuItems(menuItems);
var tableNumber = waiter.ServedTables[0].Number;
await _tabHelper.OpenTabOnTable(tabId, tableNumber);
await _tabHelper.OrderMenuItems(tabId, menuItems);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = menuItems.Sum(i => i.Price)
};
// Act
var response = await httpClient
.PutAsJsonAsync(TabRoute("close"), closeTabCommand);
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self,
LinkNames.Tab.GetTab,
LinkNames.Tab.Open
};
await response.ShouldBeAResource <CloseTabResource>(expectedLinks);
},
fixture);
public void Close()
{
CloseTab?.Invoke(this, new CloseTabEventArgs(Kfi)
{
LeaveOpen = Kfi.ParentKfi != null
});
}
public async Task CannotOrderItemsOnAClosedTab(
Guid tabId,
int tableNumber,
MenuItem[] itemsToOrder)
{
// Arrange
await _helper.AddMenuItems(itemsToOrder);
await _helper.OpenTabOnTable(tabId, tableNumber);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = 0
};
await _fixture.SendAsync(closeTabCommand);
var orderItemsCommand = new OrderMenuItems
{
TabId = tabId,
ItemNumbers = itemsToOrder.Select(i => i.Number).ToList()
};
// Act
var result = await _fixture.SendAsync(orderItemsCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Validation);
}
public void CloseTab(IntPtr ieHandle, string tabCaptionToClose)
{
AccessibleObjectFromWindow(GetDirectUIHWND(ieHandle), OBJID.OBJID_WINDOW, ref accessible);
if (accessible == null)
{
throw new Exception();
}
var ieDirectUIHWND = new IEAccessible(ieHandle);
foreach (IEAccessible accessor in ieDirectUIHWND.Children)
{
foreach (var child in accessor.Children)
{
foreach (var tab in child.Children)
{
if (tab.Name == tabCaptionToClose)
{
foreach (var CloseTab in tab.Children)
{
CloseTab.Activate();
}
return;
}
}
}
}
}
public async Task CanCloseTab(Guid tabId)
{
// Arrange
await OpenTab(tabId);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = 10.0m
};
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
result.HasValue.ShouldBeTrue();
await AssertTabExists(
tabId,
t => t.Id == tabId &&
t.IsOpen == false &&
t.TotalPaid == closeTabCommand.AmountPaid &&
// We haven't ordered anything, therefore we expect the full price to be counted as a tip
t.TipValue == closeTabCommand.AmountPaid);
}
private Task Add(Command command)
{
switch (command)
{
case Command.ToggleWindow:
return(ToggleWindow.Add());
case Command.NextTab:
return(NextTab.Add());
case Command.PreviousTab:
return(PreviousTab.Add());
case Command.NewTab:
return(NewTab.Add());
case Command.CloseTab:
return(CloseTab.Add());
case Command.NewWindow:
return(NewWindow.Add());
case Command.ShowSettings:
return(ShowSettings.Add());
case Command.Copy:
return(Copy.Add());
case Command.Paste:
return(Paste.Add());
}
return(Task.CompletedTask);
}
public void CloseTab(IntPtr ieHandle, int tabIndexToClose)
{
AccessibleObjectFromWindow(GetDirectUIHWND(ieHandle), OBJID.OBJID_WINDOW, ref accessible);
if (accessible == null)
{
throw new Exception();
}
var ieDirectUIHWND = new IEAccessible(ieHandle);
foreach (IEAccessible accessor in ieDirectUIHWND.Children)
{
foreach (var child in accessor.Children)
{
foreach (var tab in child.Children)
{
object tabIndex = tab.accessible.get_accState(0);
if ((int)tabIndex == tabIndexToClose)
{
foreach (var CloseTab in tab.Children)
{
CloseTab.Activate();
}
return;
}
}
}
}
}
public Task GetTabHistoryShouldReturnProperHypermediaLinks(Fixture fixture) =>
_apiHelper.InTheContextOfAWaiter(
waiter => async httpClient =>
{
// Arrange
var openTabCommand = new OpenTab
{
Id = Guid.NewGuid(),
CustomerName = "Some customer",
TableNumber = waiter.ServedTables[0].Number
};
var closeTabCommand = new CloseTab
{
TabId = openTabCommand.Id,
AmountPaid = 0
};
await _fixture.SendAsync(openTabCommand);
await _fixture.SendAsync(closeTabCommand);
// Act
var response = await httpClient.GetAsync(TabRoute("history"));
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self
};
var resource = await response.ShouldBeAResource <TabsContainerResource>(expectedLinks);
resource.Items.ShouldAllBe(r => r.Links.Count > 0);
},
fixture);
public async Task CloseTab(Guid tabId, decimal amountPaid)
{
var command = new CloseTab
{
TabId = tabId,
AmountPaid = amountPaid
};
await _fixture.SendAsync(command);
}
public IEnumerable <dynamic> Handle(CloseTab c)
{
yield return(new TabClosed
{
Id = c.Id,
AmountPaid = c.AmountPaid,
OrderValue = this.servedItemsValue,
TipValue = c.AmountPaid - this.servedItemsValue
});
}
public void refreshColor()
{
if (!bgTab)
{
bg.Background = color;
}
else
{
bg.Background = Brushes.Transparent;
CloseTab.ImageSource("close_Tab.png");
}
}
public async Task CannotCloseATabTwice(Guid tabId, int tableNumber)
{
// Arrange
await _helper.OpenTabOnTable(tabId, tableNumber);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = 0 // This should be OK as we haven't ordered anything
};
await _fixture.SendAsync(closeTabCommand);
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Validation);
}
public void CloseIETab(string tabCaptionToClose)
{
foreach (Accessible accessor in Children)
{
foreach (var child in accessor.Children)
{
foreach (var tab in child.Children)
{
if (tab.Name == tabCaptionToClose)
{
foreach (var CloseTab in tab.Children)
{
CloseTab.Activate();
}
return;
}
}
}
}
}
public async Task CanCloseTabWithoutTip(Guid tabId, int tableNumber)
{
// Arrange
await _helper.OpenTabOnTable(tabId, tableNumber);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = 0 // This should be OK as we haven't ordered anything
};
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
await _helper.AssertTabExists(
closeTabCommand.TabId,
t => t.IsOpen == false &&
t.TipValue == 0);
}
public Tab(string title, MainWindow mw, UserControl uc, System.Windows.Media.Brush brush)
{
Dispatcher.BeginInvoke((Action)(() =>
{
darkColor = false;
InitializeComponent();
form = uc;
color = brush;
actualForeground = Brushes.Black;
form.HorizontalAlignment = HorizontalAlignment.Stretch;
form.VerticalAlignment = VerticalAlignment.Stretch;
label_TabTitle.Content = title;
Loaded += Tab_Loaded;
mainWindow = mw;
closeTabMargin = 8;
favIconMargin = 6;
CloseTab.ImageSource("close_Tab.png");
CloseTab.SetImageScale(8);
CloseTab.SetRippleMargin(1);
}));
}
public async Task CannotPayLessThanOwed(Guid tabId, int tableNumber, MenuItem[] menuItemsToOrder)
{
// Arrange
await _helper.AddMenuItems(menuItemsToOrder);
await _helper.OpenTabOnTable(tabId, tableNumber);
await _helper.OrderMenuItems(tabId, menuItemsToOrder);
await _helper.ServeMenuItems(tabId, menuItemsToOrder);
var closeTabCommand = new CloseTab
{
TabId = tabId,
AmountPaid = menuItemsToOrder.Sum(i => i.Price) - 1 // Will always be less than the price of the items
};
// Act
var result = await _fixture.SendAsync(closeTabCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Validation);
}
public async Task <IActionResult> CloseTab([FromBody] CloseTab command) => (await Mediator.Send(command) .MapAsync(_ => ToEmptyResourceAsync <CloseTabResource>(x => x.TabId = command.TabId))) .Match(Ok, Error);
public Task <Option <Unit, Error> > Handle(CloseTab request, CancellationToken cancellationToken) =>
ValidateCommandIsNotEmpty(request).FlatMapAsync(command =>
GetTabIfNotClosed(command.TabId, cancellationToken).
FilterAsync(async tab => command.AmountPaid >= tab.ServedItemsValue, Errors.Tab.TriedToPayLessThanTheBill).MapAsync(tab =>
PublishEvents(tab.Id, tab.CloseTab(command.AmountPaid))));
public void closeTab(string url)
{
CloseTab?.Invoke(this, new StringMessageEventArgs {
Message = url
});
}
