public void Setup()
{
this.element = new TableElementWithParam()
.WithLine($"{IDENTIFIER}{KEY}={VALUE}");
this.element.Init();
}
public void Setup()
{
this.element = new TableElementNormal()
.WithLine("20= ");
this.element.Init();
}
/// <summary>
/// Join the current table element with a new one
/// </summary>
/// <param name="newTable">The table to append</param>
public static void Join(this ITableElement currentTable, ITableElement newTable)
{
ValidateHeaders(currentTable, newTable);
foreach (var row in newTable.GetRows())
{
currentTable.AddRow(row);
}
}
private static void ValidateHeaders(ITableElement currentTable, ITableElement newTable)
{
int count = 0;
var headers = currentTable.GetHeadersDict();
foreach (string newTableHeader in newTable.GetHeadersString())
{
if (headers.ContainsKey(newTableHeader))
{
count++;
}
}
if (count != currentTable.Headers.Count)
{
throw new InvalidOperationException("The table have different headers");
}
}
/// <summary>
/// Creates a new datatable object with the current table element
/// </summary>
/// <param name="rowCallback">A callback to get the desired rows</param>
public static DataTable CreateDataTable(this ITableElement tableElement, Func <IEnumerable <IDictionary <string, TableCell> >, IEnumerable <IDictionary <string, TableCell> > > rowCallback)
{
DataTable tb = new DataTable();
foreach (TableCell column in tableElement.Headers)
{
tb.Columns.Add(column.Text);
}
foreach (var row in rowCallback(tableElement.GetRows()))
{
DataRow newRow = tb.NewRow();
foreach (TableCell column in tableElement.Headers)
{
newRow[column.Text] = row[column.Text].Text;
}
tb.Rows.Add(newRow);
}
return(tb);
}
/// <summary>
/// Creates a new datatable object with the current table element
/// </summary>
/// <param name="cellCallback">A callback to set the desired value for each cell in the table element</param>
/// <returns>A datatable that represents the table element</returns>
public static DataTable CreateDataTable(this ITableElement tableElement, Func <TableCell, object> cellCallback)
{
DataTable tb = new DataTable();
foreach (TableCell column in tableElement.Headers)
{
tb.Columns.Add(column.Text);
}
foreach (var row in tableElement.GetRows())
{
DataRow newRow = tb.NewRow();
foreach (TableCell column in tableElement.Headers)
{
newRow[column.Text] = cellCallback(row[column.Text]);
}
tb.Rows.Add(newRow);
}
return(tb);
}
/// <summary>
/// Creates a new datatable object with the current table element
/// </summary>
/// <returns>A datatable that represents the table element (by default all values of datatable are strings)</returns>
public static DataTable CreateDataTable(this ITableElement tableElement)
{
DataTable tb = new DataTable();
foreach (TableCell column in tableElement.Headers)
{
tb.Columns.Add(column.Text);
}
foreach (var row in tableElement.GetRows())
{
DataRow newRow = tb.NewRow();
foreach (TableCell column in tableElement.Headers)
{
newRow[column.Text] = row[column.Text].Text;
}
tb.Rows.Add(newRow);
}
return(tb);
}
/// <summary>
/// Add cell to the row.
/// </summary>
/// <param name="order"></param>
/// <param name="content"></param>
/// <param name="tableElement"></param>
public void AddCell(int order, object content, ITableElement tableElement)
{
TableCellViewModel tableCell = new TableCellViewModel(order, content, tableElement);
this.cells.Add(tableCell);
}
/// <summary>
/// Map entities to <see cref="TableViewModel"/> by using the decorated properties of the view model entity implementation by <seealso cref="TableColumnAttribute"/>.
/// </summary>
/// <typeparam name="T">ViewModel entity implementation.</typeparam>
/// <param name="entitiesResult"></param>
/// <param name="actions"></param>
/// <returns></returns>
public static TableViewModel Map <T>(PaginatedList <T> entitiesResult, params TableRowActionViewModel[] actions)
{
Type dtoType = typeof(T);
TableViewModel tableViewModel = new TableViewModel();
var properties = dtoType.GetProperties();
List <TableColumnAttribute> dtoAttributes = new List <TableColumnAttribute>();
foreach (var property in properties)
{
if (property.HasAttribute <TableColumnAttribute>())
{
dtoAttributes.Add((TableColumnAttribute)property.GetCustomAttributes(typeof(TableColumnAttribute), false).FirstOrDefault());
}
}
List <string> tableHeaders = dtoAttributes.OrderBy(x => x.Order).Select(x => x.Name).Distinct().ToList();
tableHeaders.ForEach(x => { tableViewModel.Header.AddCell(x); });
if (entitiesResult.ItemsCount > 0)
{
foreach (var entity in entitiesResult.Items)
{
TableRowViewModel tableRow = new TableRowViewModel();
foreach (var property in properties)
{
if (property.GetCustomAttributes(typeof(EntityIdentifierAttribute), false).Length > 0)
{
tableRow.Identifier = property.GetValue(entity)?.ToString();
}
if (property.HasAttribute <TableColumnAttribute>())
{
TableColumnAttribute propertyAttribute = (TableColumnAttribute)property.GetCustomAttributes(typeof(TableColumnAttribute), false).FirstOrDefault();
ITableElement tableElementInstance = (ITableElement)Activator.CreateInstance(propertyAttribute.UIElementType);
tableRow.AddCell(
propertyAttribute.Order,
property.GetValue(entity),
tableElementInstance);
}
}
foreach (var action in actions)
{
List <string> parsedParameters = new List <string>();
foreach (var parameter in action.RawParameters)
{
if (parameter.StartsWith("[", StringComparison.OrdinalIgnoreCase) && parameter.EndsWith("]", StringComparison.OrdinalIgnoreCase))
{
string propertyName = parameter.Substring(1, parameter.Length - 2);
string propertyValue = entity.GetType().GetProperty(propertyName)?.GetValue(entity).ToString();
parsedParameters.Add(propertyValue);
}
else
{
parsedParameters.Add(parameter);
}
}
tableRow.AddAction(action, parsedParameters);
}
tableViewModel.AddRow(tableRow);
}
}
tableViewModel.SetPagination(entitiesResult.CurrentPage, entitiesResult.PagesCount);
return(tableViewModel);
}
/// <summary>
/// Initializes a new instance of the <see cref="TableCellViewModel"/> class.
/// </summary>
/// <param name="order"></param>
/// <param name="content"></param>
/// <param name="tableElement"></param>
public TableCellViewModel(int order, object content, ITableElement tableElement)
{
this.Order = order;
this.TableElement = tableElement;
this.TableElement.DataSource = content;
}
