Angular Data Grid - Web API Service

import { NgModule, Component, enableProdMode } from '@angular/core';

import { BrowserModule } from '@angular/platform-browser';

import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';

import { DxDataGridModule } from 'devextreme-angular';

import * as AspNetData from 'devextreme-aspnet-data-nojquery';

import { DetailGridComponent } from './detail-grid/detail-grid.component';

​

if (!/localhost/.test(document.location.host)) {

  enableProdMode();

}

​

let modulePrefix = '';

// @ts-ignore

if (window && window.config?.packageConfigPaths) {

  modulePrefix = '/app';

}

​

@Component({

    styleUrls: [`app/app.component.css`],

  selector: 'demo-app',

  templateUrl: `app/app.component.html`,

})

export class AppComponent {

  customersData: AspNetData.CustomStore;

​

  shippersData: AspNetData.CustomStore;

​

  dataSource: AspNetData.CustomStore;

​

  url: string;

​

  constructor() {

    this.url = 'https://js.devexpress.com/Demos/NetCore/api/DataGridWebApi';

​

    this.dataSource = AspNetData.createStore({

      key: 'OrderID',

      loadUrl: `${this.url}/Orders`,

      insertUrl: `${this.url}/InsertOrder`,

      updateUrl: `${this.url}/UpdateOrder`,

      deleteUrl: `${this.url}/DeleteOrder`,

      onBeforeSend(method, ajaxOptions) {

        ajaxOptions.xhrFields = { withCredentials: true };

      },

    });

​

    this.customersData = AspNetData.createStore({

      key: 'Value',

      loadUrl: `${this.url}/CustomersLookup`,

      onBeforeSend(method, ajaxOptions) {

        ajaxOptions.xhrFields = { withCredentials: true };

      },

    });

​

    this.shippersData = AspNetData.createStore({

      key: 'Value',

      loadUrl: `${this.url}/ShippersLookup`,

      onBeforeSend(method, ajaxOptions) {

        ajaxOptions.xhrFields = { withCredentials: true };

      },

    });

  }

}

​

@NgModule({

  imports: [

    BrowserModule,

    DxDataGridModule,

  ],

  declarations: [AppComponent, DetailGridComponent],

  bootstrap: [AppComponent],

})

export class AppModule { }

​

platformBrowserDynamic().bootstrapModule(AppModule);

​

// In real applications, you should not transpile code in the browser.

// You can see how to create your own application with Angular and DevExtreme here:

// https://js.devexpress.com/Documentation/Guide/Angular_Components/Getting_Started/Create_a_DevExtreme_Application/

const componentNames = [

  'accordion',

  'action-sheet',

  'autocomplete',

  'bar-gauge',

  'box',

  'bullet',

  'button-group',

  'button',

  'calendar',

  'chart',

  'chat',

  'check-box',

  'circular-gauge',

  'color-box',

  'context-menu',

  'data-grid',

  'date-box',

  'date-range-box',

  'defer-rendering',

  'diagram',

  'draggable',

  'drawer',

  'drop-down-box',

  'drop-down-button',

  'file-manager',

  'file-uploader',

  'filter-builder',

  'form',

  'funnel',

  'gallery',

  'gantt',

  'html-editor',

  'linear-gauge',

  'list',

  'load-indicator',

  'load-panel',

  'lookup',

  'map',

  'menu',

  'multi-view',

  'nested',

  'number-box',

  'pagination',

  'pie-chart',

  'pivot-grid-field-chooser',

  'pivot-grid',

  'polar-chart',

  'popover',

  'popup',

  'progress-bar',

  'radio-group',

  'range-selector',

  'range-slider',

  'recurrence-editor',

  'resizable',

  'responsive-box',

  'sankey',

  'scheduler',

  'scroll-view',

  'select-box',

  'slider',

  'sortable',

  'sparkline',

  'speed-dial-action',

  'splitter',

  'switch',

  'tab-panel',

  'tabs',

  'tag-box',

  'text-area',

  'text-box',

  'tile-view',

  'toast',

  'toolbar',

  'tooltip',

  'tree-list',

  'tree-map',

  'tree-view',

  'validation-group',

  'validation-summary',

  'validator',

  'vector-map',

];

window.exports = window.exports || {};

window.config = {

  transpiler: 'ts',

  typescriptOptions: {

    module: 'system',

    emitDecoratorMetadata: true,

    experimentalDecorators: true,

  },

  meta: {

    'typescript': {

      'exports': 'ts',

    },

    'devextreme-aspnet-data-nojquery': {

      'esModule': true,

    },

    'devextreme/time_zone_utils.js': {

      'esModule': true,

    },

    'devextreme/localization.js': {

      'esModule': true,

    },

    'devextreme/viz/palette.js': {

      'esModule': true,

    },

    '@angular/platform-browser-dynamic': {

      'esModule': true,

    },

    '@angular/platform-browser': {

      'esModule': true,

    },

    '@angular/core': {

      'esModule': true,

    },

    '@angular/common': {

      'esModule': true,

    },

    '@angular/common/http': {

      'esModule': true,

    },

    '@angular/animations': {

      'esModule': true,

    },

    '@angular/forms': {

      'esModule': true,

    },

    'openai': {

      'esModule': true,

    },

  },

  paths: {

    'npm:': 'https://unpkg.com/',

    'bundles:': 'bundles/',

    'externals:': 'bundles/externals/',

  },

  map: {

    'ts': 'npm:plugin-typescript@8.0.0/lib/plugin.js',

    'typescript': 'npm:typescript@4.2.4/lib/typescript.js',

    'jszip': 'npm:jszip@3.10.1/dist/jszip.min.js',

    /* @angular */

    '@angular/compiler': 'bundles:@angular/compiler.umd.js',

    '@angular/platform-browser-dynamic': 'bundles:@angular/platform-browser-dynamic.umd.js',

    '@angular/core': 'bundles:@angular/core.umd.js',

    '@angular/core/primitives/signals': 'bundles:@angular/core.primitives.signals.umd.js',

    '@angular/common': 'bundles:@angular/common.umd.js',

    '@angular/common/http': 'bundles:@angular/common-http.umd.js',

    '@angular/platform-browser': 'bundles:@angular/platform-browser.umd.js',

    '@angular/platform-browser/animations': 'bundles:@angular/platform-browser.umd.js',

    '@angular/forms': 'bundles:@angular/forms.umd.js',

    /* devextreme */

    'devextreme': 'npm:devextreme@24.2.6/cjs',

    '@devextreme/runtime': 'npm:@devextreme/runtime@3.0.12',

    'devextreme/bundles/dx.all': 'npm:devextreme@24.2.6/bundles/dx.all.js',

    'devextreme-quill': 'npm:devextreme-quill@1.7.1/dist/dx-quill.min.js',

    'devexpress-diagram': 'npm:devexpress-diagram@2.2.15',

    'devexpress-gantt': 'npm:devexpress-gantt@4.1.60',

    /* devextreme-angular umd maps */

    'devextreme-angular': 'bundles:devextreme-angular/devextreme-angular.umd.js',

    'devextreme-angular/core': 'bundles:devextreme-angular/devextreme-angular-core.umd.js',

    'devextreme-angular/http': 'bundles:devextreme-angular/devextreme-angular-http.umd.js',

    ...componentNames.reduce((acc, name) => {

      acc[`devextreme-angular/ui/${name}`] = `bundles:devextreme-angular/devextreme-angular-ui-${name}.umd.js`;

      acc[`devextreme-angular/ui/${name}/nested`] = `bundles:devextreme-angular/devextreme-angular-ui-${name}-nested.umd.js`;

      return acc;

    }, {}),

    'tslib': 'npm:tslib/tslib.js',

    'rxjs': 'npm:rxjs@7.5.3/dist/bundles/rxjs.umd.js',

    'rxjs/operators': 'npm:rxjs@7.5.3/dist/cjs/operators/index.js',

    'devextreme-aspnet-data-nojquery': 'npm:devextreme-aspnet-data-nojquery@5.0.0/index.js',

    'rrule': 'npm:rrule@2.6.4/dist/es5/rrule.js',

    'luxon': 'npm:luxon@3.4.4/build/global/luxon.min.js',

    'es6-object-assign': 'npm:es6-object-assign',

    'inferno': 'npm:inferno@7.4.11/dist/inferno.min.js',

    'inferno-compat': 'npm:inferno-compat/dist/inferno-compat.min.js',

    'inferno-create-element': 'npm:inferno-create-element@7.4.11/dist/inferno-create-element.min.js',

    'inferno-dom': 'npm:inferno-dom/dist/inferno-dom.min.js',

    'inferno-hydrate': 'npm:inferno-hydrate/dist/inferno-hydrate.min.js',

    'inferno-clone-vnode': 'npm:inferno-clone-vnode/dist/inferno-clone-vnode.min.js',

    'inferno-create-class': 'npm:inferno-create-class/dist/inferno-create-class.min.js',

    'inferno-extras': 'npm:inferno-extras/dist/inferno-extras.min.js',

    // Prettier

    'prettier/standalone': 'npm:prettier@2.8.8/standalone.js',

    'prettier/parser-html': 'npm:prettier@2.8.8/parser-html.js',

  },

  packages: {

    'app': {

      main: './app.component.ts',

      defaultExtension: 'ts',

    },

    'devextreme': {

      defaultExtension: 'js',

    },

    'devextreme/events/utils': {

      main: 'index',

    },

    'devextreme/common/core/events/utils': {

      main: 'index',

    },

    'devextreme/events': {

      main: 'index',

    },

    'es6-object-assign': {

      main: './index.js',

      defaultExtension: 'js',

    },

    'rxjs': {

      defaultExtension: 'js',

    },

    'rxjs/operators': {

      defaultExtension: 'js',

    },

  },

  packageConfigPaths: [

    'npm:@devextreme/*/package.json',

    'npm:@devextreme/runtime@3.0.12/inferno/package.json',

    'npm:rxjs@7.5.3/package.json',

    'npm:rxjs@7.5.3/operators/package.json',

    'npm:devexpress-diagram@2.2.15/package.json',

    'npm:devexpress-gantt@4.1.60/package.json',

  ],

};

System.config(window.config);

// System.import('@angular/compiler').catch(console.error.bind(console));

​

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml" lang="en">

  <head>↔</head>

​

  <body class="dx-viewport">

    <div class="demo-container">

      <demo-app>Loading...</demo-app>

    </div>

  </body>

</html>

​

<dx-data-grid [dataSource]="dataSource" [showBorders]="true"> </dx-data-grid>

​

import { Component, Input, AfterViewInit } from '@angular/core';

import DataSource from 'devextreme/data/data_source';

import * as AspNetData from 'devextreme-aspnet-data-nojquery';

​

let modulePrefix = '';

// @ts-ignore

if (window && window.config?.packageConfigPaths) {

  modulePrefix = '/app';

}

​

@Component({

  selector: 'detail-grid',

  templateUrl: `app/detail-grid/detail-grid.component.html`,

  styleUrls: [`app/detail-grid/detail-grid.component.css`],

  providers: [],

})

export class DetailGridComponent implements AfterViewInit {

  @Input() key: number;

​

  dataSource: DataSource;

​

  ngAfterViewInit() {

    this.dataSource = new DataSource({

      store: AspNetData.createStore({

        loadUrl: 'https://js.devexpress.com/Demos/NetCore/api/DataGridWebApi/OrderDetails',

        loadParams: { orderID: this.key },

        onBeforeSend(method, ajaxOptions) {

          ajaxOptions.xhrFields = { withCredentials: true };

        },

      }),

    });

  }

}

​

using DevExtreme.AspNet.Data;

using DevExtreme.AspNet.Mvc;

using Newtonsoft.Json;

using System;

using System.Linq;

using System.Net;

using System.Net.Http;

using System.Net.Http.Formatting;

using System.Web.Http;

using DevExtreme.MVC.Demos.Models.Northwind;

using DevExtreme.MVC.Demos.Models.DataGrid;

using System.Collections.Generic;

​

namespace DevExtreme.MVC.Demos.Controllers {

    [Route("api/DataGridWebApi/{action}", Name = "DataGridWebApi")]

    public class DataGridWebApiController : ApiController {

        InMemoryNorthwindContext _nwind = new InMemoryNorthwindContext();

​

        [HttpGet]

        public HttpResponseMessage Orders(DataSourceLoadOptions loadOptions) {

            return Request.CreateResponse(DataSourceLoader.Load(_nwind.Orders, loadOptions));

        }

​

        [HttpPost]

        public HttpResponseMessage InsertOrder(FormDataCollection form) {

            var values = form.Get("values");

​

            var newOrder = new Order();

            JsonConvert.PopulateObject(values, newOrder);

​

            Validate(newOrder);

            if(!ModelState.IsValid)

                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState.GetFullErrorMessage());

​

            _nwind.Orders.Add(newOrder);

            _nwind.SaveChanges();

​

            return Request.CreateResponse(HttpStatusCode.Created, newOrder);

        }

​

        [HttpPut]

        public HttpResponseMessage UpdateOrder(FormDataCollection form) {

            var key = Convert.ToInt32(form.Get("key"));

            var values = form.Get("values");

            var order = _nwind.Orders.First(o => o.OrderID == key);

​

            JsonConvert.PopulateObject(values, order);

​

            Validate(order);

            if(!ModelState.IsValid)

                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState.GetFullErrorMessage());

​

            _nwind.SaveChanges();

​

            return Request.CreateResponse(HttpStatusCode.OK, order);

        }

​

        [HttpDelete]

        public void DeleteOrder(FormDataCollection form) {

            var key = Convert.ToInt32(form.Get("key"));

            var order = _nwind.Orders.First(o => o.OrderID == key);

​

            _nwind.Orders.Remove(order);

            _nwind.SaveChanges();

        }

​

        // additional actions

​

        [HttpGet]

        public HttpResponseMessage OrderDetails(int orderID, DataSourceLoadOptions loadOptions) {

            return Request.CreateResponse(DataSourceLoader.Load(

                from i in _nwind.Order_Details

                where i.OrderID == orderID

                select new {

                    Product = i.Product.ProductName,

                    Price = i.UnitPrice,

                    i.Quantity,

                    Sum = i.UnitPrice * i.Quantity

                },

                loadOptions

            ));

        }

​

        [HttpGet]

        public HttpResponseMessage ShippersLookup(DataSourceLoadOptions loadOptions) {

            var lookup = from i in _nwind.Shippers

                         orderby i.CompanyName

                         select new {

                             Value = i.ShipperID,

                             Text = i.CompanyName

                         };

​

            return Request.CreateResponse(DataSourceLoader.Load(lookup, loadOptions));

        }

​

        [HttpGet]

        public HttpResponseMessage CustomersLookup(DataSourceLoadOptions loadOptions) {

            var lookup = from i in _nwind.Customers

                         let text = i.CompanyName + " (" + i.Country + ")"

                         orderby i.CompanyName

                         select new {

                             Value = i.CustomerID,

                             Text = text

                         };

​

            return Request.CreateResponse(DataSourceLoader.Load(lookup, loadOptions));

        }

​

        [HttpPost]

        public HttpResponseMessage Batch(List<DataChange> changes) {

            foreach(var change in changes) {

                Order order;

​

                if(change.Type == "update" || change.Type == "remove") {

                    var key = Convert.ToInt32(change.Key);

                    order = _nwind.Orders.First(o => o.OrderID == key);

                } else {

                    order = new Order();

                }

​

                if(change.Type == "insert" || change.Type == "update") {

                    JsonConvert.PopulateObject(change.Data.ToString(), order);

​

                    Validate(order);

                    if(!ModelState.IsValid)

                        return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState.GetFullErrorMessage());

​

                    if(change.Type == "insert") {

                        _nwind.Orders.Add(order);

                    }

                    change.Data = order;

                } else if(change.Type == "remove") {

                    _nwind.Orders.Remove(order);

                }

            }

​

            _nwind.SaveChanges();

​

            return Request.CreateResponse(HttpStatusCode.OK, changes);

        }

    }

​

}

​

using System;

using System.Collections.Generic;

using System.Data.Entity;

​

namespace DevExtreme.MVC.Demos.Models.Northwind {

    public class InMemoryNorthwindContext : InMemoryDataContext<Order> {

        readonly NorthwindContext _nwind = new NorthwindContext();

​

        public DbSet<Customer> Customers => _nwind.Customers;

        public DbSet<Order_Detail> Order_Details => _nwind.Order_Details;

        public ICollection<Order> Orders => ItemsInternal;

        public DbSet<Shipper> Shippers => _nwind.Shippers;

​

        protected override IEnumerable<Order> Source => _nwind.Orders;

        protected override int GetKey(Order item) => item.OrderID;

        protected override void SetKey(Order item, int key) => item.OrderID = key;

    }

}

​