public void TestMainMethods()
{
_server.WithPaging(5);
string gridState = _server.Grid.GetState();
var query = StringExtensions.GetQuery(gridState);
foreach (var element in query)
{
Assert.IsTrue(_server.Grid.Query.ContainsKey(element.Key));
Assert.AreEqual(_server.Grid.Query[element.Key], element.Value);
}
Dictionary <string, StringValues> store = new Dictionary <string, StringValues>();
store.Add("grid-search", "TEST");
store.Add("grid-page", "2");
_server = new GridServer <TestModel>(Enumerable.Empty <TestModel>(),
new QueryCollection(store), false, "_Grid", _columns, 10);
_server.Searchable();
gridState = _server.Grid.GetState();
query = StringExtensions.GetQuery(gridState);
foreach (var element in query)
{
Assert.IsTrue(_server.Grid.Query.ContainsKey(element.Key));
Assert.AreEqual(_server.Grid.Query[element.Key], element.Value);
}
}
public ItemsDTO <Order> GetOrdersGridRows(Action <IGridColumnCollection <Order> > columns,
QueryDictionary <StringValues> query)
{
using (var context = new NorthwindDbContext(_options))
{
var repository = new OrdersRepository(context);
var server = new GridServer <Order>(repository.GetAll(), new QueryCollection(query),
true, "ordersGrid", columns)
.Sortable()
.WithPaging(10)
.Filterable()
.WithMultipleFilters()
.Groupable(true)
.Searchable(true, false);
// return items to displays
var items = server.ItemsToDisplay;
// uncomment the following lines are to test null responses
//items = null;
//items.Items = null;
//items.Pager = null;
return(items);
}
}
public async Task <ActionResult> Grid()
{
List <Cost> costs = await _context.Costs.Include(x => x.Adapter)
.ThenInclude(c => c.Credentials)
.Include(a => a.Adapter).ThenInclude(p => p.Provider)
.ToListAsync();
DbSet <OrganizationUnit> ous = _context.OrganizationUnits;
var vms = _context.Vms.ToList();
foreach (var vm in vms)
{
vm.PoolShortName = ous.FirstOrDefault(p => vm.Name.Contains(p.PoolShortName))?.PoolShortName ?? ous.Single(d => d.Id == 1).PoolShortName;
vm.Cost = costs.SingleOrDefault(x => x.DatacenterId == vm.DatacenterId && x.AdapterId == vm.AdapterId);
vm.TotalCost = (vm.Cpu * vm.Cost.CpuCost) + (vm.MemoryGb * vm.Cost.MemoryCost) + (vm.HddSize * vm.Cost.HddCost);
}
var server = new GridServer <Vm>(vms, Request.Query, true, "grid", Client.Pages.BillingPage.Columns, 7)
.Sortable()
.Searchable()
.Filterable()
.ChangePageSize(true)
.Selectable(true)
.WithGridItemsCount();
return(Ok(server.ItemsToDisplay));
}
public void Init()
{
HttpContext context = new DefaultHttpContext();
var viewContextMock = new Mock <ViewContext>();
_server = new GridServer <TestModel>(Enumerable.Empty <TestModel>(),
context.Request.Query, false, "_Grid", _columns, 10);
}
public ActionResult GetOrdersAutoGenerateColumns()
{
var repository = new OrdersRepository(_context);
IGridServer <Order> server = new GridServer <Order>(repository.GetAll(), Request.Query,
true, "ordersGrid", null)
.AutoGenerateColumns();
return(Ok(server.ItemsToDisplay));
}
public ItemsDTO <Camper> GetCampersGridRows(string scheduleId, Action <IGridColumnCollection <Camper> > columns, QueryDictionary <StringValues> query)
{
var server = new GridServer <Camper>(
GetCampersForScheduleId(scheduleId),
new QueryCollection(query), true,
"camperScheduleGrid", columns);
return(server.ItemsToDisplay);
}
public ItemsDTO <IActivityBlock> GetActivityBlocksGridRows(string scheduleId, Action <IGridColumnCollection <IActivityBlock> > columns, QueryDictionary <StringValues> query)
{
var server = new GridServer <IActivityBlock>(
LookupScheduleById(scheduleId).SelectMany(ad => ad.ScheduledBlocks),
new QueryCollection(query), true,
"activityScheduleGrid", columns);
return(server.ItemsToDisplay);
}
public ItemsDTO <Order> GetOrdersGridRows(QueryDictionary <StringValues> query)
{
var repository = new OrdersRepository(_context);
var server = new GridServer <Order>(repository.GetAll(), new QueryCollection(query),
true, "ordersGrid", null).AutoGenerateColumns();
// return items to displays
return(server.ItemsToDisplay);
}
private ItemsDTO <GuestEntity> GetGridRows(Action <IGridColumnCollection <GuestEntity> > columns,
QueryDictionary <StringValues> query)
{
VolatileSettings.GridQueries["guestsGrid"] = query;
var server = new GridServer <GuestEntity>(guests, new QueryCollection(query),
true, "guestsGrid", columns, 15).Sortable().Filterable().WithMultipleFilters();
// Return items to displays
return(server.ItemsToDisplay);
}
private void tabMain_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (_lasttabMainSelectIndex == TabMain.SelectedIndex)
{
return;
}
_lasttabMainSelectIndex = TabMain.SelectedIndex;
if (!LoadOk)
{
return;
}
var da1 = new DoubleAnimation(0, TabMain.ActualWidth, new Duration(new TimeSpan(0, 0, 0, 0, 100)));
var da2 = new DoubleAnimation(0, TabMain.ActualHeight, new Duration(new TimeSpan(0, 0, 0, 0, 100)));
switch (TabMain.SelectedIndex)
{
case 0:
GridGame.BeginAnimation(FrameworkElement.WidthProperty, da1); GridGame.BeginAnimation(FrameworkElement.HeightProperty, da2);
break;
case 1:
GridConfig.BeginAnimation(FrameworkElement.WidthProperty, da1); GridConfig.BeginAnimation(FrameworkElement.HeightProperty, da2);
break;
case 2:
GridVersion.BeginAnimation(FrameworkElement.WidthProperty, da1); GridVersion.BeginAnimation(FrameworkElement.HeightProperty, da2);
if (GridVersion.btnRefreshRemoteVer.IsEnabled && GridVersion.listRemoteVer.HasItems == false)
{
GridVersion.RefreshVersion();
}
break;
case 3:
GridForge.BeginAnimation(FrameworkElement.WidthProperty, da1); GridForge.BeginAnimation(FrameworkElement.HeightProperty, da2);
if (GridForge.btnReForge.IsEnabled && GridForge.treeForgeVer.HasItems == false)
{
GridForge.RefreshForge();
}
break;
case 4:
GridServer.BeginAnimation(FrameworkElement.WidthProperty, da1); GridServer.BeginAnimation(FrameworkElement.HeightProperty, da2);
if (GridServer.btnReflushServer.IsEnabled && GridServer.listServer.HasItems == false)
{
GridServer.ReflushSever();
}
break;
case 5:
gridUpdateInfo.BeginAnimation(FrameworkElement.WidthProperty, da1);
gridUpdateInfo.BeginAnimation(FrameworkElement.HeightProperty, da2);
break;
}
}
public ActionResult GetOrdersGridForSample()
{
var repository = new OrdersRepository(_context);
IGridServer <Order> server = new GridServer <Order>(repository.GetAll(), Request.Query,
true, "ordersGrid", GridSample.Columns, 10)
.Sortable()
.Filterable()
.WithMultipleFilters();
return(Ok(server.ItemsToDisplay));
}
public ItemsDTO <LeadGeneration> GetOrdersGridRows(Action <IGridColumnCollection <LeadGeneration> > columns, QueryDictionary <StringValues> query,
IEnumerable <LeadGeneration> _leads)
{
var server = new GridServer <LeadGeneration>(_leads, new QueryCollection(query), true, "ordersGrid", columns, 10)
.Sortable()
.Filterable()
.WithMultipleFilters();
// return items to displays
return(server.ItemsToDisplay);
}
public ItemsDTO <TViewModel> GetRows(Action <IGridColumnCollection <TViewModel> > columns,
QueryDictionary <StringValues> query)
{
var models = FetchViewModels();
var server = new GridServer <TViewModel>(models, new QueryCollection(query),
true, "circlesGrid", columns, 50)
.Sortable()
.Filterable();
// return items to displays
return(server.ItemsToDisplay);
}
public GridNetClient(GridServer server, GridNetClientManager netManager, GridServerNetworkSystem netSystem, string workerName)
{
WorkerName = workerName;
_gridServer = server;
_gridServerNetwork = netSystem;
_clientNetManager = netManager;
_tempReceivedFiles = new List <GridJobFile>();
IsAcceptingNewTasks = true;
_isDisconnecting = false;
_shouldRemove = false;
_checkDisconnectTime = DateTime.Now.Ticks;
}
public ActionResult GetSubgridRTL(int OrderId)
{
Action <IGridColumnCollection <OrderDetail> > columns = c =>
{
/* Adding "OrderID" column: */
c.Add(o => o.OrderID)
.Titled("Order Number")
.SortInitialDirection(GridSortDirection.Descending)
.ThenSortByDescending(o => o.ProductID)
.SetWidth(100);
/* Adding "ProductID" column: */
c.Add(o => o.ProductID)
.Titled("Product Number")
.SetWidth(100);
/* Adding "ProductName" column: */
c.Add(o => o.Product.ProductName)
.Titled("Product Name")
.SetWidth(250);
/* Adding "Quantity" column: */
c.Add(o => o.Quantity)
.Titled("Quantity")
.SetCellCssClassesContraint(o => o.Quantity >= 50 ? "red" : "")
.SetWidth(100)
.Format("{0:F}");
/* Adding "UnitPrice" column: */
c.Add(o => o.UnitPrice)
.Titled("Unit Price")
.SetWidth(100)
.Format("{0:F}");
};
var requestCulture = HttpContext.Features.Get <IRequestCultureFeature>();
var locale = requestCulture.RequestCulture.UICulture.TwoLetterISOLanguageName;
var orderDetails = _orderDetailsRepository.GetForOrder(OrderId);
var server = new GridServer <OrderDetail>(orderDetails, Request.Query,
false, "orderDetailsGrid" + OrderId.ToString(), columns, 10, locale)
.SetRowCssClasses(item => item.Quantity > 10 ? "success" : string.Empty)
.Sortable()
.Filterable()
.SetStriped(true)
.WithMultipleFilters()
.WithGridItemsCount()
.SetDirection(GridDirection.RTL)
.SetRemoveDiacritics <NorthwindDbContext>("RemoveDiacritics");
return(PartialView("_SubGrid", server.Grid));
}
public ItemsDTO <ActivityDefinition> GetActivityDefinitionsGridRows(string activitySet,
QueryDictionary <StringValues> query)
{
var server = new GridServer <ActivityDefinition>(_activitySets[activitySet],
new QueryCollection(query),
true, "activityDefinitionGrid", null).AutoGenerateColumns()
.Sortable()
.Filterable()
.WithMultipleFilters();
// return items to displays
return(server.ItemsToDisplay);
}
public ItemsDTO <Order> GetOrdersGridRows(Action <IGridColumnCollection <Order> > columns,
QueryDictionary <StringValues> query)
{
var repository = new OrdersRepository(_context);
var server = new GridServer <Order>(repository.GetAll(), new QueryCollection(query),
true, "ordersGrid", columns, 10)
.Sortable()
.Filterable()
.WithMultipleFilters();
// return items to displays
return(server.ItemsToDisplay);
}
public ItemsDTO<TestModel> GetAllService(Action<IGridColumnCollection<TestModel>> columns,
QueryDictionary<StringValues> query)
{
GridServer<TestModel> server = new GridServer<TestModel>(GetTestData().AsQueryable(),
new QueryCollection(query), true, "_Grid", columns);
server.Sortable()
.Filterable()
.WithMultipleFilters();
// return items to displays
return server.ItemsToDisplay;
}
public ActionResult GetOrdersGridWithSubgrids()
{
var repository = new OrdersRepository(_context);
IGridServer <Order> server = new GridServer <Order>(repository.GetAll(), Request.Query,
true, "ordersGrid", ColumnCollections.OrderColumnsWithSubgrids)
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters();
var items = server.ItemsToDisplay;
return(Ok(items));
}
public ActionResult GetTrucksGrid()
{
var repository = new EmployeeRepository(_context);
IGridServer <Truck> server = new GridServer <Truck>(GetAllTrucks(), Request.Query,
true, "trucksGrid", Trucks.Columns)
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var items = server.ItemsToDisplay;
return(Ok(items));
}
public ActionResult GetCustomersGrid()
{
var repository = new CustomersRepository(_context);
IGridServer <Customer> server = new GridServer <Customer>(repository.GetAll(), Request.Query,
true, "customersGrid", ColumnCollections.CustomersColumns)
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var items = server.ItemsToDisplay;
return(Ok(items));
}
public ActionResult GetOrdersGridAllFeatures()
{
var repository = new OrdersRepository(_context);
IGridServer <Order> server = new GridServer <Order>(repository.GetAll(), Request.Query,
true, "ordersGrid", c => ColumnCollections.OrderColumnsAllFeatures(c, null, null))
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.Searchable(true, false);
var items = server.ItemsToDisplay;
return(Ok(items));
}
public ActionResult GetOrderDetailsGridAllFeatures(int OrderId)
{
var orderDetails = (new OrderDetailsRepository(_context)).GetForOrder(OrderId);
var server = new GridServer <OrderDetail>(orderDetails, Request.Query,
false, "orderDetailsGrid" + OrderId.ToString(), ColumnCollections.OrderDetailColumnsAllFeatures)
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters();
var items = server.ItemsToDisplay;
return(Ok(items));
}
public ItemsDTO <OrderVM> GetOrdersGridRows(Action <IGridColumnCollection <OrderVM> > columns,
QueryDictionary <StringValues> query)
{
var server = new GridServer <OrderVM>(_orderVmRepository.All, new QueryCollection(query), true,
"ordersGrid", columns, 10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.Searchable(true, false);
// return items to displays
var items = server.ItemsToDisplay;
return(items);
}
public ItemsDTO <CryptoAsset> GetCryptoAssetGridRows(Action <IGridColumnCollection <CryptoAsset> > columns,
QueryDictionary <StringValues> query)
{
var getAllStatusAwaiter = GetAllStatus().GetAwaiter();
getAllStatusAwaiter.OnCompleted(() =>
{
});
var server = new GridServer <CryptoAsset>(getAllStatusAwaiter.GetResult(), new QueryCollection(query),
true, "cryptoAssetsGrid", columns, 10);
// return items to displays
return(server.ItemsToDisplay);
}
public ItemsDTO <WeatherForecast> GetForecastAsync(Action <IGridColumnCollection <WeatherForecast> > columns, QueryDictionary <StringValues> query)
{
DateTime startDate = DateTime.Now;
var rng = new Random();
var arr = Enumerable.Range(1, 5).Select(index => new WeatherForecast {
Date = startDate.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
});
var server = new GridServer <WeatherForecast>(arr, new QueryCollection(query),
true, "RegistrationsGrid", columns, 10)
.Sortable();
return(server.ItemsToDisplay);
}
public ActionResult GetAllSalesOrder()
{
var repository = new SalesOrdersRepository(_context);
IGridServer <SalesOrder> server = new GridServer <SalesOrder>(repository.GetAll(), Request.Query,
true, "salesOrdersGrid", c => ColumnCollections.SalesOrderColumnsWithCustomer(c, null, null))
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var salesOrders = server.ItemsToDisplay;
return(Ok(salesOrders));
}
public ActionResult GetAllRevenue()
{
var repository = new RevenuesRepository(_context);
IGridServer <Revenue> server = new GridServer <Revenue>(repository.GetAll(), Request.Query,
true, "revenuesGrid", c => ColumnCollections.RevenueColumns(c, null))
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var revenues = server.ItemsToDisplay;
return(Ok(revenues));
}
public ActionResult GetRevenuebySalesOrderId(int salesOrderId)
{
var repository = new RevenuesRepository(_context).GetForSalesOrder(salesOrderId);
var server = new GridServer <Revenue>(repository, Request.Query,
true, "revenuesGrid" + salesOrderId.ToString(), c => ColumnCollections.RevenueColumns(c, null))
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var revenues = server.ItemsToDisplay;
return(Ok(revenues));
}
public ActionResult GetOrdersGridordersAutoGenerateColumns()
{
var repository = new OrdersRepository(_context);
IGridServer <Order> server = new GridServer <Order>(repository.GetAll(), Request.Query,
true, "ordersGrid", null)
.AutoGenerateColumns()
.WithPaging(10)
.Sortable()
.Filterable()
.WithMultipleFilters()
.WithGridItemsCount();
var items = server.ItemsToDisplay;
return(Ok(items));
}
