/// <summary>
/// New table definition.
/// </summary>
/// <example>
/// Database.AddTable("Users", t => {
/// t.PrimaryKey(); // Adds long field named Id and makes it identity primary key.
/// t.String("Login"); // Adds String field named Login.
/// t.String("Password"); // Adds String field named Password.
/// t.String("FullName").Null(); // Adds nullable String field named FullName.
/// });
/// </example>
/// <param name="transformationProvider">The transformation provider.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="tableDefinition">The table definition expressions.</param>
public static void AddTable(this ITransformationProvider transformationProvider, String tableName, Action <Table> tableDefinition)
{
var table = new AddTable(tableName);
tableDefinition(table);
table.Migrate(transformationProvider);
}
private async Task <TestHubConnection> BuildTestHubConnectionWithoutAssignedWaiter <TEvent>(
HireWaiter hireAssignedWaiterCommand,
HireWaiter hireUnassignedWaiterCommand,
AddTable addTableCommand,
Register registerCommand)
{
await HireWaiterWithTable(hireAssignedWaiterCommand, addTableCommand);
await _fixture.SendAsync(hireUnassignedWaiterCommand);
await _fixture.SendAsync(registerCommand);
var assignWaiterToAccountCommand = new AssignWaiterToAccount
{
AccountId = registerCommand.Id,
// Purposefully assigning another waiter to the account, that is not assigned to the table
WaiterId = hireUnassignedWaiterCommand.Id
};
await _fixture.SendAsync(assignWaiterToAccountCommand);
var accessToken = (await _authHelper
.Login(registerCommand.Email, registerCommand.Password))
.TokenString;
var testConnection = BuildTestConnection <TEvent>(accessToken);
return(testConnection);
}
public async Task UnassignedToWaitersAccountsShouldNotReceiveBillRequestedMessage(
HireWaiter hireAssignedWaiterCommand,
HireWaiter hireUnassignedWaiterCommand,
AddTable addTableCommand,
Register registerCommand)
{
// Arrange
var testConnection = await BuildTestHubConnectionWithoutAssignedWaiter <BillRequested>(
hireAssignedWaiterCommand,
hireUnassignedWaiterCommand,
addTableCommand,
registerCommand);
await testConnection.OpenAsync();
var requestBillCommand = new RequestBill
{
TableNumber = addTableCommand.Number
};
// Act
await _fixture.SendAsync(requestBillCommand);
// Assert
await testConnection.VerifyNoMessagesWereReceived();
}
public async Task CanAssignTable(HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
// Arrange
await _fixture.SendAsync(addTableCommand);
await _fixture.SendAsync(hireWaiterCommand);
var assignTableCommand = new AssignTable
{
WaiterId = hireWaiterCommand.Id,
TableNumber = addTableCommand.Number
};
// Act
var result = await _fixture.SendAsync(assignTableCommand);
// Assert
var tableInDb = await _fixture.ExecuteDbContextAsync(dbContext =>
dbContext
.Tables
.Include(t => t.Waiter)
.ThenInclude(w => w.ServedTables)
.FirstOrDefaultAsync(t => t.Id == addTableCommand.Id));
tableInDb.ShouldNotBeNull();
tableInDb.WaiterId.ShouldBe(hireWaiterCommand.Id);
tableInDb.Waiter.ShouldNotBeNull();
tableInDb.Waiter.ShortName.ShouldBe(hireWaiterCommand.ShortName);
tableInDb.Waiter.ServedTables.ShouldContain(t => t.Id == addTableCommand.Id &&
t.Number == assignTableCommand.TableNumber);
}
private void butAdd_Click(object sender, EventArgs e)
{
AddTable ins = new AddTable();
this.Hide();
ins.ShowDialog();
this.Show();
}
private void btnNew_Click(object sender, EventArgs e)
{
AddTable tbl = new AddTable();
if (tbl.ShowDialog() == DialogResult.OK)
{
LoadGrid();
}
}
static void Main(string[] args)
{
//create a dictionary
Dictionary<Database, List<DatabaseTable>> dictionary = new Dictionary<Database, List<DatabaseTable>>();
List<DatabaseTable> list = new List<DatabaseTable>();
//create a list<string> for column_names to be stored
List<string> column_names=new List<string>();
//Populate the list of column names
column_names.Add("StatusID");
column_names.Add("Status_title");
column_names.Add("Status_description");
//create and initialize databasetable object "table1"
DatabaseTable table1 = new DatabaseTable("Status", "StatusID",column_names);
//create a new database object
Database database1 = new Database("Database");
//populate the database object with databasetable object
database1.PopulateTable(table1);
DatabaseTable table2 = new DatabaseTable("Client", "ClientID", column_names);
database1.PopulateTable(table2);
//Add the two tables into the list
list.Add(table1);
list.Add(table2);
//populate the dictionary with the Database name and with corresponding List<table> objects in it
dictionary.Add(database1, list);
//Rename a particular table in a database with a new name
DatabaseTable d=database1.RenameTable("Status", "NewStatus", list);
list.Remove(table1);
list.Add(d);
IBinaryFile bf = new BinaryFile();
long getRowSize = bf.GetRowSize();
long size = bf.GetPrimaryKeySize();
DataTypes pkey = bf.GetPrimaryKeyType();
AddTable add = new AddTable();
//create a new binary file
add.CreateTable("Status");
//add a node into the binary file with the Table name
add.CreateNode("Status", 10, 19, 4, 25, 35);
TestWriter tw = new TestWriter();
tw.bWriter();
tw.search("C:\\Users\\TestBinary.dat");
}
public async Task CanAddTable(AddTable command)
{
// Arrange
// Act
var result = await _fixture.SendAsync(command);
// Assert
var tableInDb = await _fixture.ExecuteDbContextAsync(dbContext =>
dbContext.Tables.FirstOrDefaultAsync(t => t.Id == command.Id));
tableInDb.ShouldNotBeNull();
tableInDb.Number.ShouldBe(command.Number);
}
private async Task HireWaiterWithTable(HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
await _fixture.SendAsync(addTableCommand);
await _fixture.SendAsync(hireWaiterCommand);
var assignTableCommand = new AssignTable
{
WaiterId = hireWaiterCommand.Id,
TableNumber = addTableCommand.Number
};
await _fixture.SendAsync(assignTableCommand);
}
public async Task SetupWaiterWithTable(HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
await _fixture.SendAsync(addTableCommand);
await _fixture.SendAsync(hireWaiterCommand);
var assignTableCommand = new AssignTable
{
TableNumber = addTableCommand.Number,
WaiterId = hireWaiterCommand.Id
};
await _fixture.SendAsync(assignTableCommand);
}
public async Task CannotAssignUnexistingWaiter(AddTable addTableCommand)
{
// Arrange
await _fixture.SendAsync(addTableCommand);
var assignTableCommand = new AssignTable
{
WaiterId = Guid.NewGuid(), // Irrelevant since we haven't hired any waiters
TableNumber = addTableCommand.Number
};
// Act
var result = await _fixture.SendAsync(assignTableCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.NotFound);
}
public async Task CannotAddTableWithATakenNumber(AddTable addFirstTableCommand)
{
// Arrange
await _fixture.SendAsync(addFirstTableCommand);
var addTableWithTheSameNumberCommand = new AddTable
{
Id = Guid.NewGuid(),
Number = addFirstTableCommand.Number
};
// Act
var result = await _fixture.SendAsync(addTableWithTheSameNumberCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Conflict);
}
public Task AddTableShouldReturnProperHypermediaLinks(AddTable command, Fixture fixture) =>
_apiHelper.InTheContextOfAManager(
manager => async httpClient =>
{
// Act
var response = await httpClient
.PostAsJsonAsync(TableRoute(), command);
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self,
LinkNames.Table.GetAll
};
await response.ShouldBeAResource <AddTableResource>(expectedLinks);
},
fixture);
public async Task CannotOrderItemsOnAnUnexistingTab(
MenuItem[] itemsToOrder,
HireWaiter hireWaiterCommand,
AddTable addTableCommand)
{
// Arrange
await _helper.SetupWaiterWithTable(hireWaiterCommand, addTableCommand);
// Purposefully not opening a tab
var orderItemsCommand = new OrderMenuItems
{
TabId = Guid.NewGuid(),
ItemNumbers = itemsToOrder.Select(i => i.Number).ToList()
};
// Act
var result = await _fixture.SendAsync(orderItemsCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.NotFound);
}
public async Task BillRequestedMessageShouldBeCorrectlySentWhenMultipleSubscribersAreAttached(
HireWaiter hireAssignedWaiterCommand,
HireWaiter hireUnassignedWaiterCommand,
AddTable addTableCommand,
Register registerAssignedAccount,
Register registerUnassignedAccount)
{
// Arrange
var invalidTestConnection = await BuildTestHubConnectionWithoutAssignedWaiter <BillRequested>(
hireAssignedWaiterCommand,
hireUnassignedWaiterCommand,
addTableCommand,
registerUnassignedAccount);
var validTestConnection = await BuildTestTableActionConnection <BillRequested>(
hireAssignedWaiterCommand,
addTableCommand,
registerAssignedAccount);
await invalidTestConnection.OpenAsync();
await validTestConnection.OpenAsync();
var requestBillCommand = new RequestBill
{
TableNumber = addTableCommand.Number
};
// Act
await _fixture.SendAsync(requestBillCommand);
// Assert
await invalidTestConnection.VerifyNoMessagesWereReceived();
await validTestConnection.VerifyMessageReceived <BillRequested>(
e => e.TableNumber == addTableCommand.Number &&
e.WaiterId == hireAssignedWaiterCommand.Id,
Times.Once());
}
public Task RequestBillShouldReturnProperHypermediaLinks(HireWaiter hireWaiter, AddTable addTable, Fixture fixture) =>
_apiHelper.InTheContextOfAnAuthenticatedUser(
async httpClient =>
{
// Arrange
await _tabHelper.SetupWaiterWithTable(hireWaiter, addTable);
var requestBill = new RequestBill
{
TableNumber = addTable.Number
};
// Act
var response = await httpClient
.PostAsJsonAsync(TableRoute($"{addTable.Number}/requestBill"), requestBill);
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self,
LinkNames.Table.CallWaiter,
LinkNames.Table.GetAll
};
await response.ShouldBeAResource <RequestBillResource>(expectedLinks);
},
fixture);
public async Task CannotAssignTheSameWaiterTwice(HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
// Arrange
await _fixture.SendAsync(addTableCommand);
await _fixture.SendAsync(hireWaiterCommand);
var assignTableCommand = new AssignTable
{
WaiterId = hireWaiterCommand.Id,
TableNumber = addTableCommand.Number
};
await _fixture.SendAsync(assignTableCommand);
// Act
var result = await _fixture.SendAsync(assignTableCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Conflict);
}
/// <summary>
/// Event invoker
/// </summary>
protected virtual void OnAddTable(TableModel e)
{
AddTable?.Invoke(this, e);
}
private void btnNew_Click_1(object sender, EventArgs e)
{
AddTable frm = new AddTable();
frm.Show();
}
public Task AssignTableShouldReturnProperHypermediaLinks(HireWaiter hireWaiterCommand, AddTable addTableCommand, Fixture fixture) =>
_apiHelper.InTheContextOfAManager(
manager => async httpClient =>
{
// Arrange
await _fixture.SendAsync(hireWaiterCommand);
await _fixture.SendAsync(addTableCommand);
var assignTableCommand = new AssignTable
{
WaiterId = hireWaiterCommand.Id,
TableNumber = addTableCommand.Number
};
// Act
var response = await httpClient
.PostAsJsonAsync(WaiterRoute("table/assign"), assignTableCommand);
// Assert
var expectedLinks = new List <string>
{
LinkNames.Self,
LinkNames.Waiter.GetEmployedWaiters,
LinkNames.Waiter.Hire
};
await response.ShouldBeAResource <AssignTableResource>(expectedLinks);
},
fixture);
public async Task CanOpenTab(OpenTab openTabCommand, HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
// Arrange
await _helper.SetupWaiterWithTable(hireWaiterCommand, addTableCommand);
// Make sure we're trying to open a tab on the added table
openTabCommand.TableNumber = addTableCommand.Number;
// Act
var result = await _fixture.SendAsync(openTabCommand);
// Assert
await _helper.AssertTabExists(
openTabCommand.Id,
t => t.IsOpen == true &&
t.WaiterName == hireWaiterCommand.ShortName &&
t.CustomerName == openTabCommand.CustomerName);
}
public async Task CannotOpenExistingTab(OpenTab openTabCommand, HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
// Arrange
await _helper.SetupWaiterWithTable(hireWaiterCommand, addTableCommand);
// Make sure we're trying to open a tab on the added table
openTabCommand.TableNumber = addTableCommand.Number;
// Open a tab once
await _fixture.SendAsync(openTabCommand);
// Act
// Make sure we won't be getting a conflict on the table numbers
openTabCommand.TableNumber += 10;
var result = await _fixture.SendAsync(openTabCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Conflict);
}
public async Task AssignedWaitersShouldReceiveBillRequestedMessage(HireWaiter hireWaiterCommand, AddTable addTableCommand, Register registerCommand)
{
// Arrange
var testConnection = await BuildTestTableActionConnection <BillRequested>(
hireWaiterCommand,
addTableCommand,
registerCommand);
await testConnection.OpenAsync();
var requestBillCommand = new RequestBill
{
TableNumber = addTableCommand.Number
};
// Act
await _fixture.SendAsync(requestBillCommand);
// Assert
await testConnection.VerifyMessageReceived <BillRequested>(
e => e.TableNumber == addTableCommand.Number &&
e.WaiterId == hireWaiterCommand.Id,
Times.Once());
}
public async Task CannotOpenATabOnATakenTable(OpenTab openTabCommand, HireWaiter hireWaiterCommand, AddTable addTableCommand)
{
// Arrange
await _helper.SetupWaiterWithTable(hireWaiterCommand, addTableCommand);
// Make sure we're trying to open a tab on the added table
openTabCommand.TableNumber = addTableCommand.Number;
// Open a tab once
await _fixture.SendAsync(openTabCommand);
// Act
// Setting a new id for the command so we don't get a conflict on the tab id
openTabCommand.Id = Guid.NewGuid();
var result = await _fixture.SendAsync(openTabCommand);
// Assert
result.ShouldHaveErrorOfType(ErrorType.Conflict);
}
private async Task <TestHubConnection> BuildTestTableActionConnection <TEvent>(HireWaiter hireWaiterCommand, AddTable addTableCommand, Register registerCommand)
{
await HireWaiterWithTable(hireWaiterCommand, addTableCommand);
await _fixture.SendAsync(registerCommand);
var assignWaiterToAccountCommand = new AssignWaiterToAccount
{
AccountId = registerCommand.Id,
WaiterId = hireWaiterCommand.Id
};
await _fixture.SendAsync(assignWaiterToAccountCommand);
var accessToken = (await _authHelper
.Login(registerCommand.Email, registerCommand.Password))
.TokenString;
return(BuildTestConnection <TEvent>(accessToken));
}
public async Task <IActionResult> AddTable([FromBody] AddTable command) => (await Mediator.Send(command) .MapAsync(ToEmptyResourceAsync <AddTableResource>)) .Match(Ok, Error);
