@using Kendo.Mvc.UI

    @(Html.Kendo().DateTimePicker()
            .Name("DateTimeSampled")
            .Format("MM/dd/yyyy HH:mm")
            .ParseFormats(new[] { "MM/dd/yyyy HH mm", "MM/dd/yyyy HH:mm", "MM/dd/yyyy HHmm"})
            .TimeFormat("HH:mm")
            .Events(e =>
            {
                  e.Change("change").Open("open").Close("close");
            })
    )

<script>
    function open(e) {
        console.log("Open :: " + e.view + "-view");
    }

    function close(e) {
        console.log("Close :: " + e.view + "-view");
    }

    function change(e) {
        console.log("Change :: " + kendo.toString(this.value(), 'g'));
        if (e.view == "date") {
           //var picker = e.sender.data("kendoDateTimePicker");
           var picker = $("#DateTimeSampled").data("kendoDateTimePicker");
           console.log(picker);
           //picker.close();
           //e.sender.close();
           var info = kendo.caret(e.sender.element);
           kendo.caret(e.sender.element, info[0] - 5, info[1]); 
        }
    }
</script>

@(Html.Kendo().DateRangePicker()
    .Name("startEnd")
    .Messages(m => m.StartLabel("Start").EndLabel("End"))
)

@(Html.Kendo().Grid<CCPartnerTabDialogDto>()
    .Name("Grid_CCPartnerTabDialog")

    .Columns(columns =>
    {
        columns.Bound(c => c.FILIALID).Title("Fields").Width(200);
    })
    .DataSource(datasource => datasource
        .Ajax()
        .Read(read => read.Action("Read", "CCPartnerTabDialog"))

        .Filter(f => f.Add(val => val.RCDSTS).IsEqualTo(" "))

        .PageSize(30))
    .Filterable(filter => filter.Mode(GridFilterMode.Row))
    .Scrollable()
    .Height("750")
    .Sortable()
    .Reorderable(r => r.Columns(true))
    .Pageable()
    .Resizable(rs => rs.Columns(true))
    .ClientDetailTemplateId("Grid_CCPartnerTabDialog_HierarchyRowTemplate")
    .Events(events =>
    {
        events.DataBound("dataBound");
        events.DetailInit("CCPartnerTabDialogInit");
    }))

<script id="Grid_CCPartnerTabDialog_HierarchyRowTemplate" type="text/kendo-tmpl">

    @(Html.Kendo().TabStrip()
        .Name("TabStrip_CCPartnerTabDialog_Hierarchy_#=PID#")
        .Collapsible(true)
        .Items(tabs =>
        {
            tabs.Add().Text("Partner").Content(@<text>
                @(Html.Kendo().Grid<CCPartnerDto>()
                    .Name("Grid_CCPartner_Hierarchy_#=PID#")
                    .Columns(columns =>
                    {
                        columns.Bound(c => c.PID).Title("PID");
                        columns.Bound(c => c.ERPNME).Title("ERP");

                        columns.Command(command => { command.Edit(); });
                    })
                    .Width("600")
                    .DataSource(datasource => datasource
                        .Ajax()
                        .Model(model =>
                        {
                            model.Id(p => p.PID);
                            model.Field(p => p.ERPNME);
                            model.Field(p => p.SUBSFLAG);
                            model.Field(p => p.PROVFLAG);
                        })
                        .Read(read => read.Action("Read", "CCPartner", new { values = new string[] { "#=PID#" } }))

                        .Create(create => create.Action("Insert", "CCPartner"))
                        .Update(upd => upd.Action("Update", "CCPartner"))
                        .Destroy(del => del.Action("Delete", "CCPartner"))
                    )
                    .ToClientTemplate())
                </text>);

            tabs.Add().Text("Alias").Content(@<text>
                @(Html.Kendo().Grid<CCPartnerAliasDto>()
                .Name("Grid_CCPartnerAlias_Hierarchy_#=PID#")
                .Columns(columns =>
                {
                            columns.Bound(c => c.PID).Title("PartnerId").Width(200).Locked(true).Editable("notEditable");

                            columns.Command(command => { command.Edit(); command.Destroy(); });
                        })
                .ToolBar(toolbar => { toolbar.Create(); })
                .DataSource(datasource => datasource
                    .Ajax()

                    .Model(model =>
                    {
                        model.Id(p => p.PID);
                    })

                    .Read(read => read.Action("Read", "CCPartnerAlias", new { values = new string[] { "#=PID#" } }))

                    .Create(create => create.Action("Insert", "CCPartnerAlias"))
                    .Update(upd => upd.Action("Update", "CCPartnerAlias"))
                    .Destroy(del => del.Action("Delete", "CCPartnerAlias"))

                    .Filter(f => f.Add(val => val.RCDSTS).IsEqualTo(" "))

                    .PageSize(30))
                .Pageable()
                .Selectable()
                .Sortable()
                .Resizable(rs => rs.Columns(true))
                .ToClientTemplate())
                </text>);
        })
        .ToClientTemplate())

using Kendo.Mvc.Extensions;
using Kendo.Mvc.UI;
using Microsoft.AspNetCore.Mvc;
using WEB.BIM.DataLayer.Interface;
using WEB.BIM.DataLayer.Model.Application;
using WEB.BIM.DataLayer.Service;

namespace WEB.BIM.Controllers.Base
{
    public class ItemBaseController<TService, TModel> : BaseController<TService>
        where TService : IItemBaseService<TModel>
    {
        public ItemBaseController(ILogger logger, TService dataservice) : base(logger, dataservice)
        { }

        public async Task<ActionResult> Read([DataSourceRequest] DataSourceRequest request, params string[] values)
        {
            var result = await service.GetAsync(values);

            return Json(result.ToDataSourceResult(request));
        }
        public async Task<ActionResult> Insert([DataSourceRequest] DataSourceRequest request, TModel model)
        {
            if (model != null && ModelState.IsValid)
            {
                await service.InsertAsync(model, UserName());
            }

            return Json(new[] { model }.ToDataSourceResult(request));
        }
        public async Task<ActionResult> Update([DataSourceRequest] DataSourceRequest request, TModel model)
        {
            if(model != null && ModelState.IsValid)
            {
                await service.UpdateAsync(model, UserName());
            }

            return Json(new[] { model }.ToDataSourceResult(request));
        }
        public async Task<ActionResult> Delete([DataSourceRequest] DataSourceRequest request, TModel model)
        {
            if (model != null && ModelState.IsValid)
            {
                await service.DeleteAsync(model, UserName());
            }

            return Json(new[] { model }.ToDataSourceResult(request));
        }

    }
}

    
// get detailGrids_subSelect 
$.each(detailGrids_subSelect, function (index, value) {
        var tmp = value.getKendoGrid();
        tmp.setOptions({
            dataSource: {
                schema: { model: { fields: { PID: { defaultValue: e.data.PID } } } }
            }
        })
    })

.Model(model =>
{
  model.Id(p => p.ALIASQLF);
  model.Id(p => p.ALIASVAL);
  model.Field(f => f.ALIASQLF).DefaultValue("#=ALIASQLF#");
})

		@(Html.Kendo().Grid<TheGridName>()
				.Name("mainGrid")
				.HtmlAttributes(new { @class = "gridHeight"})
				.Columns(col =>
				{
					col.Bound(c => c.col1).Title("Test 1");
					col.Bound(c => c.col2).Title("Test 2");
					col.Bound(c => c.col3).Title("Test 3");
					col.Bound(c => c.col4).Title("Test 4");
					col.Bound(c => c.col5).Title("Test 5");
					col.Bound(c => c.col6).Title("Test 6").;
				})
				.ToolBar(toolbar =>
				{
					toolbar.Excel();
					toolbar.Pdf();
				})
				.Pdf(pdf => pdf
					.AllPages(true)
					.AvoidLinks(false)
					.PaperSize("8in" , "11.5in")
					.Margin("2cm", "1cm", "1cm", "1cm")
					.Landscape(true)
					.Scale(0.8)
					.RepeatHeaders(true)
					.FileName("Kendo UI Grid Export.pdf")
					.ProxyURL(Url.Action("Pdf_Export_Save", "Grid"))
				)
				.Sortable()
				.Scrollable()
				.Filterable()
				.Resizable(r => r.Columns(true))
				.Reorderable(r => r.Columns(true))
				.Excel(excel => excel
				.FileName("test.xlsx"))
				.Events(x =>
				{
					x.ExcelExport("excelExport");
				})
				.ColumnMenu()
				.DataSource(ds => ds.Ajax()
				.Read(r => r.Url($"?handler=Read").Data("dataFunction"))
				.ServerOperation(false)
				))