public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var product = _context.Product.Select(i => new {
i.Id,
i.StockCode,
i.Name,
i.SeoUrl,
i.Model,
i.Quantity,
i.Image,
i.TaxClassId,
i.Description,
i.Tag,
i.MetaTitle,
i.MetaDescription,
i.MetaKeyword,
i.Price
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "Id" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(product, loadOptions)));
}
public async Task <IActionResult> GetPostView(DataSourceLoadOptions loadOptions)
{
var query = from c in _context.Category
from p in _context.Post.Where(p => c.CategoryId == p.CategoryId && p.Status == PostStatus.Approved.ToString()).DefaultIfEmpty()
select new PostView
{
CategoryId = c.CategoryId,
ParentCategoryId = c.ParentId,
CategoryName = c.Name,
CompanyId = p == null? 0 : p.CompanyId,
CompanyName = p == null? "": p.Company.Name,
Description = p == null ? "" : p.Description,
Img = p == null ? "" : p.Img,
MarkCode = p == null? "" : p.MarkCode,
Price = p == null? "" : p.Price,
Title = p == null? "" : p.Title,
PostId = p == null? 0 : p.PostId
};
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "PostId" };
// loadOptions.PaginateViaPrimaryKey = true;
var data = await DataSourceLoader.LoadAsync(query, loadOptions);
return(Json(data));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var employee = _context.Employee.Select(i => new {
i.EmployeeId,
i.LastName,
i.FirstName,
i.Title,
i.ReportsTo,
i.BirthDate,
i.HireDate,
i.Address,
i.City,
i.State,
i.Country,
i.PostalCode,
i.Phone,
i.Fax,
i.Email
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "EmployeeId" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(employee, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var products = _context.Products
.Select(i => new
{
i.ProductId,
i.ProductName,
i.ProductDescription,
i.ProductProductionStart,
i.ProductAvailable,
i.ProductSupportId,
i.ProductEngineerId,
i.ProductCurrentInventory,
i.ProductBackorder,
i.ProductManufacturing,
i.ProductCost,
i.ProductSalePrice,
i.ProductRetailPrice,
i.ProductConsumerRating,
i.ProductCategory
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "ProductId" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(products, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var bewerbermodel = _context.uebersicht.Select(i => new {
i.Id,
i.Erstellt,
i.Datum,
i.NL,
i.Vorname,
i.Nachname,
i.PLZ,
i.Berufsgruppe,
i.Berufdetail,
i.Netzwerke,
i.Netzwerkdetail,
i.Status,
i.Vorstellung,
i.Erfolgt,
i.Eingestellt,
i.RefMail,
i.Bearbeiter
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "Id" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(bewerbermodel, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var orders = _context.Orders.Select(i => new {
i.OrderId,
i.OrderInvoiceNumber,
i.OrderCustomerId,
i.OrderCustomerLocationId,
i.OrderPoNumber,
i.OrderEmployeeId,
i.OrderDate,
i.OrderSaleAmount,
i.OrderShippingAmount,
i.OrderTotalAmount,
i.OrderShipDate,
i.OrderShipMethod,
i.OrderTerms,
i.OrderComments
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "OrderId" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(orders, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
if (loadOptions.Filter is null)
{
loadOptions.Filter = new Object[] { "Pk_Empresa", "=", 0 };
}
var CatProdServ = _uow.Query <Cat_ProductosServicios>().Select(i => new CatProdServViewModel
{
Pk_ProductoServicio = i.Pk_ProductoServicio,
Pk_Empresa = i.Pk_Empresa,
Clave_ProdServ_SAT = i.Clave_ProdServ_SAT,
Clave_Ident = i.Clave_Ident,
CodigoBarras = i.CodigoBarras,
Clave_Unidad_SAT = i.Clave_Unidad_SAT,
Unidad = i.Unidad,
Descripcion_ProdServ_Base = i.Descripcion_ProdServ_Base,
PrecioBase = i.PrecioBase,
IVAT = i.IVAT,
IEPST = i.IEPST,
IVAR = i.IVAR,
ISRR = i.ISRR,
IEstatal = i.IEstatal,
OtraRetencion = i.OtraRetencion
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "Pk_Serie" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(CatProdServ, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
if (loadOptions.Filter is null)
{
loadOptions.Filter = new Object[] { "Pk_Empresa", "=", 0 };
}
var clientes = _uow.Query <Clientes>().Select(i => new ClientesViewModel
{
Pk_Cliente = i.Pk_Cliente,
Pk_Empresa = i.Pk_Empresa, // probablemente se elimine
RazonSocial = i.RazonSocial,
Denominacion = i.Denominacion,
RFC = i.RFC,
Calle = i.Calle,
Interior = i.Interior,
Exterior = i.Exterior,
Colonia = i.Colonia,
CP = i.CP
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "Pk_Cliente" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(clientes, loadOptions)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var customers = _context.Customers.Select(i => new {
i.CustomerId,
i.FirstName,
i.LastName,
i.Company,
i.Address,
i.City,
i.State,
i.Country,
i.PostalCode,
i.Phone,
i.Fax,
i.Email,
i.SupportRepId
});
// If underlying data is a large SQL table, specify PrimaryKey and PaginateViaPrimaryKey.
// This can make SQL execution plans more efficient.
// For more detailed information, please refer to this discussion: https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "CustomerId" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(customers, loadOptions)));
}
public async Task <object> LoadJobs(DataSourceLoadOptions loadOptions)
{
var Q = _MyDbContext.Jobs.Include(j => j.Message);
var query = await DataSourceLoader.LoadAsync(Q, loadOptions);
return(query);
}
public async Task <LoadResult> Get(DataSourceLoadOptions loadOptions, [FromQuery] AccountingRecordsSearchRequest request)
{
var response =
await _accountingRecordsService.Search(request) as WrappedResponse <IQueryable <AccountingRecord> >;
return(await DataSourceLoader.LoadAsync(response?.Data, loadOptions));
}
public async Task <LoadResult> Get(DataSourceLoadOptions loadOptions, [FromQuery] CustomerDocumentSettingSearchRequest request)
{
var response = await _customerDocumentSettingsService
.Search(request) as WrappedResponse <IQueryable <CustomerDocumentSettings> >;
return(await DataSourceLoader.LoadAsync(response?.Data, loadOptions));
}
public async Task <HttpResponseMessage> Get(DataSourceLoadOptions loadOptions)
{
var view_uebersicht = _context.view_uebersicht.Select(i => new
{
i.Id,
i.Kennzeichen,
i.Marke,
i.Modell,
i.Fahrzeughalter,
i.Niederlassung,
i.Kraftstoff,
i.Neuwagen,
i.Status,
i.EinkaufId,
i.ListenpreisB,
i.EKPreisB,
i.Erstzulassung,
i.KMDatum,
i.Kaufdatum,
i.KMStand,
});
// If you work with a large amount of data, consider specifying the PaginateViaPrimaryKey and PrimaryKey properties.
// In this case, keys and data are loaded in separate queries. This can make the SQL execution plan more efficient.
// Refer to the topic https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/336.
// loadOptions.PrimaryKey = new[] { "Id" };
// loadOptions.PaginateViaPrimaryKey = true;
return(Request.CreateResponse(await DataSourceLoader.LoadAsync(view_uebersicht, loadOptions)));
}
public static async Task RunAsync <T>(IQueryable <T> data)
{
var loadOptions = new SampleLoadOptions {
RequireTotalCount = true,
Take = 1,
RemoteGrouping = true
};
{
var loadResult = await DataSourceLoader.LoadAsync(data, loadOptions);
Assert.Equal(3, loadResult.totalCount);
Assert.Single(loadResult.data);
}
{
loadOptions.TotalSummary = new[] {
new SummaryInfo {
SummaryType = "sum", Selector = nameof(IDataItem.Value)
}
};
var loadResult = await DataSourceLoader.LoadAsync(data, loadOptions);
Assert.Equal(6m, loadResult.summary[0]);
}
Assert.Contains(loadOptions.ExpressionLog, i => i.EndsWith(".Count()"));
Assert.Contains(loadOptions.ExpressionLog, i => i.EndsWith(".Take(1)"));
Assert.Contains(loadOptions.ExpressionLog, i => i.Contains(".GroupBy"));
}
public async Task NotSupported()
{
var error = await Record.ExceptionAsync(async delegate {
await DataSourceLoader.LoadAsync(SAMPLE_DATA, new SampleLoadOptions());
});
Assert.True(error is NotSupportedException);
}
public async Task <IActionResult> OrdersLookup(DataSourceLoadOptions loadOptions)
{
var lookup = from i in _context.Orders
orderby i.OrderShipMethod
select new { Value = i.OrderId, Text = i.OrderShipMethod };
return(Json(await DataSourceLoader.LoadAsync(lookup, loadOptions)));
}
public async Task <LoadResult> Get(DataSourceLoadOptions loadOptions, [FromQuery] DocumentNumberSequenceSearchRequest request)
{
var response =
(WrappedResponse <IQueryable <DocumentNumberSequence> >) await _numberSequencesService
.Search(request);
return(await DataSourceLoader.LoadAsync(response.Data, loadOptions));
}
public async Task <LoadResult> BindDevExp(DataSourceLoadOptions loadOptions)
{
var data = _uow.NavigationMenuRepo
.TableNoTracking
.ProjectTo <NavigationMenuForListDto>(_mapper.ConfigurationProvider);
return(await DataSourceLoader.LoadAsync(data, loadOptions));
}
public async Task <IActionResult> GetOrganizasyon(DataSourceLoadOptions arama)
{
var veri = _context.Organizasyon.Include(p => p.Sirket);
arama.PrimaryKey = new[] { "id" };
arama.PaginateViaPrimaryKey = true;
return(Ok(await DataSourceLoader.LoadAsync(veri, arama)));
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
var data = _userManager.Users;
var result = await DataSourceLoader.LoadAsync(data, loadOptions);
return(Json(result));
}
public async Task <IActionResult> GetSirket(DataSourceLoadOptions arama)
{
var veri = _context.Sirket;
arama.PrimaryKey = new[] { "id" };
arama.PaginateViaPrimaryKey = true;
return(Ok(await DataSourceLoader.LoadAsync(veri, arama)));
}
public async Task <IActionResult> EmployeesLookup(DataSourceLoadOptions loadOptions)
{
var lookup = from i in _context.Employees
orderby i.EmployeeFirstName
select new { Value = i.EmployeeId, Text = i.EmployeeFirstName };
return(Json(await DataSourceLoader.LoadAsync(lookup, loadOptions)));
}
public async Task <LoadResult> Get(DataSourceLoadOptions loadOptions)
{
var user = await _accountService.GetUser(User);
var query = _mapper.ProjectTo <GoodReceivedNoteBindingModel>(_grnService.GetAll()
.FilterByUserWareHouses(user));
return(await DataSourceLoader.LoadAsync(query, loadOptions));
}
public async Task <IActionResult> GetExecutionTestsPivot(DataSourceLoadOptions loadOptions)
{
var source = _executionTestsLogicService.GetExecutionTestsForPivot();
loadOptions.PrimaryKey = new[] { "Id" };
loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(source, loadOptions)));
}
public async Task <IActionResult> GetResume(DataSourceLoadOptions loadOptions)
{
var empresas = _uow.Query <Empresas>().Select(i => new EmpresasResumenViewModel {
Pk_Empresa = i.Pk_Empresa,
Denominacion = i.Denominacion
});
return(Json(await DataSourceLoader.LoadAsync(empresas, loadOptions)));
}
public async Task <LoadResult> Get(DataSourceLoadOptions loadOptions)
{
var user = await _accountService.GetUser(User);
var query = _mapper.ProjectTo <PurchaseOrderBindingModel>(_purchaseOrderService.GetAll()
.FilterByUserWareHousesOptionally(user));
return(await DataSourceLoader.LoadAsync(query, loadOptions));
}
public async Task <LoadResult> GetStockAdjustmentsBtProductId(long id, DataSourceLoadOptions loadOptions)
{
var user = await _accountService.GetUser(User);
var query = _mapper.ProjectTo <ProductStockAdjustmentBindingModel>(_stockService
.GetStockAdjustmentsByProductId(id).FilterByUserWareHouses(user));
return(await DataSourceLoader.LoadAsync(query, loadOptions));
}
public async Task <LoadResult> DataSourceLoadAsync(DataSourceLoadOptionsBase loadOptions)
{
using (var uow = _uowFactory.CreateUnitOfWork())
{
return(await DataSourceLoader.LoadAsync(
uow.CreateRepository <IWordRepository>().GetContext().Words,
loadOptions));
}
}
public async Task <IActionResult> Get(DataSourceLoadOptions loadOptions)
{
_context.Database.ExecuteSqlRaw("[dbo].[GETSTELLEN]");
var stellenanzeigen = _context.Stellenanzeigen
.FromSqlRaw <Stellenangebote>("SELECT * FROM STELLENANZEIGEN");
return(Json(await DataSourceLoader.LoadAsync(stellenanzeigen, loadOptions)));
}
// GET api/<controller>
public async Task <IHttpActionResult> Get([FromUri] DataSourceLoadOptions loadOptions)
{
UserTableBLL bll = new UserTableBLL();
var results = bll.GetAll();
loadOptions.PrimaryKey = new[] { "UserID" };
//loadOptions.PaginateViaPrimaryKey = true;
return(Json(await DataSourceLoader.LoadAsync(results, loadOptions)));
}