Asp.net mvc 服务器端剑道调度器

我想在我的MVC应用程序中使用剑道调度程序。 但问题在于计划任务获取。因为这不在服务器端。 我也做过谷歌，但仍然没有得到任何关于如何使用服务器端剑道网格的建议 目前我从以下位置引用剑道调度程序：

但这是在客户端，即。它从数据库中读取所有数据

我需要服务器端计划程序，原因如下：

---

如果数据库有数百万个计划，即前一天+当前日期+未来几个月，那么在这种情况下，我只需要当前月/周/日的信息，我需要服务器端剑道调度程序。

服务器端调度程序很简单。客户端配置：

$("#scheduler").kendoScheduler({
   // highlightning just the parts important for server-side sourcing
   dataSource: {
     batch: true,
     transport: {
       read: {
         url: "/Services/kendo-scheduler/read",
         dataType: "json",
         contentType: "application/json; charset=utf-8",
         type: "POST"
       },
       update: {
          url: "/Services/kendo-scheduler/update",
          dataType: "json",
          contentType: "application/json; charset=utf-8",
          type: "POST"
        },
        create: {
          url: "/Services/kendo-scheduler/create",
          dataType: "json",
          contentType: "application/json; charset=utf-8",
          type: "POST"
        },
        destroy: {
          url: "/Services/kendo-scheduler/destroy",
          dataType: "json",
          contentType: "application/json; charset=utf-8",
          type: "POST"
        },
        parameterMap: function (options, operation) {
          var result = options;
          if (operation === "read") {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var result = {
              start: scheduler.view().startDate(),
              end: scheduler.view().endDate()
            };

            return kendo.stringify(result);
          }
          return kendo.stringify(options);
        }
      },
      serverFiltering: true,
      schema: {
        data: "items",
        model: {
          id: "taskId",
          fields: {
            taskId: { from: "TaskID", type: "String" },
            title: { from: "Title", defaultValue: "No title", validation: { required: true } },
            start: { type: "date", from: "Start" },
            end: { type: "date", from: "End" },
            startTimezone: { from: "StartTimezone" },
            endTimezone: { from: "EndTimezone" },
            description: { from: "Description" },
            recurrenceId: { from: "RecurrenceID", type: "Number" },
            recurrenceRule: { from: "RecurrenceRule" },
            recurrenceException: { from: "RecurrenceException" },
            ownerId: { from: "OwnerID", defaultValue: 1 },
            isAllDay: { type: "boolean", from: "IsAllDay" }
          }
        }
      }       
    }
});

服务器端我正在使用WCF，但任何rest API都可以：

合同：

[ServiceContract]
public interface ITaskService
{
  [OperationContract]
  [WebInvoke(UriTemplate = "/read", Method = "POST", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
  [Description("Return list of all events")]
  KendoTaskCollectionResponse Read(DateRange range);
  [OperationContract]
  [WebInvoke(UriTemplate = "/destroy", Method = "POST", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
  [Description("Delete an event")]
  KendoTaskCollectionResponse Destroy(KendoTaskCollectionRequest model);
  [OperationContract]
  [WebInvoke(UriTemplate = "/create", Method = "POST", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
  [Description("Create an event")]
  KendoTaskCollectionResponse Create(KendoTaskCollectionRequest model);
  [OperationContract]
  [WebInvoke(UriTemplate = "/update", Method = "POST", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
  [Description("Update an event")]
  KendoTaskCollectionResponse Update(KendoTaskCollectionRequest model);
}

[DataContract]
public class ErrorResponse : IErrorResponse
{
  [DataMember]
  public virtual string Error { get; set; }
  [DataMember]
  public virtual string ErrorUID { get; set; }
  [DataMember]
  public virtual bool IsSuccess { get; set; }
}

[DataContract]
public class KendoTaskCollectionRequest
{
  [DataMember(Name="models")]
  public IList<KendoTask> Models { get; set; }
}

[DataContract]
public class KendoTaskCollectionResponse : ErrorResponse, IClientResponse<KendoTask>
{
  public KendoTaskCollectionResponse()
  {
    Items = new List<KendoTask>();
  }

  public KendoTaskCollectionResponse(IList<KendoTask> list)
  {
    Items = new List<KendoTask>(list);
  }

  [DataMember(Name="items")]
  public IList<KendoTask> Items { get; set; }
}

public interface IClientResponse<T> : IErrorResponse
{
  IList<T> Items { get; set; }
}

[DataContract]
public class KendoTask
{
  [DataMember]
  public string TaskID { get; set; }
  [DataMember]
  public string Title { get; set; }
  [DataMember]
  public string Description { get; set; }
  [DataMember]
  public string Start { get; set; }
  [DataMember]
  public string StartTimezone { get; set; }
  [DataMember]
  public string End { get; set; }
  [DataMember]
  public string EndTimezone { get; set; }
  [DataMember]
  public string RecurrenceRule { get; set; }
  [DataMember]
  public int? RecurrenceID { get; set; }
  [DataMember]
  public string RecurrenceException { get; set; }
  [DataMember]
  public bool IsAllDay { get; set; }
  [DataMember]
  public int? OwnerID { get; set; }
}

[DataContract]
public class DateRange
{
  [DataMember(Name = "start")]
  public string Start { get; set; }
  [DataMember(Name = "end")]
  public string End { get; set; }
}

---

您使用的是哪种数据访问解决方案？EntityFramework？如果你想使用服务器端剑道，你需要Telerik的许可证。你可以在这里找到一个服务器端MVC调度器组件：就我个人而言，我觉得DevCraft Complete是最好的选择，但是也有针对剑道的单独许可证。

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class TaskService : ITaskService
{
  protected T SafeExecute<T>(Func<T> action) where T : IErrorResponse, new()
  {
    try
    {
      return action.Invoke();
    }
    catch (Exception e)
    {
      // publish the error somewhere - logs 
      var response = new T();
      // this is just for development, on prod 
      // you'd want to hide this error  
      response.Error = e.ToString();
      return response;
    }
  }

  public KendoTaskCollectionResponse Read(DateRange range)
  {
    return SafeExecute<KendoTaskCollectionResponse>(() =>
    {
      var start = DateTime.Parse(range.Start, CultureInfo.InvariantCulture);
      var end = DateTime.Parse(range.End, CultureInfo.InvariantCulture);
      // lookup to db based on start and end
      var appointments = ...;
      return new KendoTaskCollectionResponse(appointments);
    });
  }

  public KendoTaskCollectionResponse Destroy(KendoTaskCollectionRequest model)
  {
    return SafeExecute<KendoTaskCollectionResponse>(() =>
    {
      var result = new List<KendoTask>();
      if (model.Models != null)
      {
        foreach (var task in model.Models)
        {
          // delete from db here
          result.Add(task);
        }
      }
      return new KendoTaskCollectionResponse(result);
    });
  }

  public KendoTaskCollectionResponse Create(KendoTaskCollectionRequest model)
  {
    return SafeExecute<KendoTaskCollectionResponse>(() =>
    {
      var result = new List<KendoTask>();
      if (model.Models != null)
      {
        foreach (var task in model.Models)
        {
          // insert to db here, don't forget to set task.TaskID
          result.Add(task);
        }
      }
      return new KendoTaskCollectionResponse(result);
    });
  }

  public KendoTaskCollectionResponse Update(KendoTaskCollectionRequest model)
  {
    return SafeExecute<KendoTaskCollectionResponse>(() =>
    {
      var result = new List<KendoTask>();
      if (model.Models != null)
      {
        foreach (var task in model.Models)
        {
          // update db here
          result.Add(task);
        }
      }
      return new KendoTaskCollectionResponse(result);
    });
  }
}

void RegisterRoutes(RouteCollection routes) {  
  routes.Add(new ServiceRoute("Services/kendo-scheduler", new WebServiceHostFactory(), typeof(TaskService)));
}
protected void Application_Start(Object sender, EventArgs e)
{
  RegisterRoutes(RouteTable.Routes);    
}