Faire une cellule en lecture seule dans Kendo Grid si la condition est remplie
Disons que j'ai une donnée comme celle-ci:
[
{ID: 1, SomeForeignKeyID: 4, IsFkEnabled: true},
{ID: 2, SomeForeignKeyID: 9, IsFkEnabled: false}
]
Kendo Grid utilise ces données:
columns.Bound(m => m.ID);
columns.ForeignKey(p => p.SomeForeignKeyID, ViewBag.ForeignKeys as IEnumerable<object>, "Value", "Name");
Voici le problème: comment rendre la colonne ForeignKey modifiable, mais uniquement en lignes, où IsFkEnabled == true? Le mode édition est InCell.
Remarques:
- cette solution fonctionne uniquement pour l'édition dans la cellule (l'édition en ligne ou en incrustation nécessite une approche différente)
- la première approche peut entraîner des effets visuels indésirables (grille sauter) dans certaines circonstances; si vous ressentez cela, je recommande l’approche n ° 2
- l'approche n ° 2 peut ne pas fonctionner si vous souhaitez utiliser les wrappers MVC (bien qu'il soit possible d'étendre Kendo.Mvc.UI.Fluent.GridEventBuilder); dans ce cas, vous devrez lier le gestionnaire d'édition dans JS.
Approche n ° 1
Utilisez l'événement edit de la grille, puis procédez comme suit:
$("#grid").kendoGrid({
dataSource: dataSource,
height: "300px",
columns: columns,
editable: true,
edit: function (e) {
var fieldName = e.container.find("input").attr("name");
// alternative (if you don't have the name attribute in your editable):
// var columnIndex = this.cellIndex(e.container);
// var fieldName = this.thead.find("th").eq(columnIndex).data("field");
if (!isEditable(fieldName, e.model)) {
this.closeCell(); // prevent editing
}
}
});
/**
* @returns {boolean} True if the column with the given field name is editable
*/
function isEditable(fieldName, model) {
if (fieldName === "SomeForeignKeyID") {
// condition for the field "SomeForeignKeyID"
// (default to true if defining property doesn't exist)
return model.hasOwnProperty("IsFkEnabled") && model.IsFkEnabled;
}
// additional checks, e.g. to only allow editing unsaved rows:
// if (!model.isNew()) { return false; }
return true; // default to editable
}
_ { Démo ici } _ ( mis à jour pour le premier trimestre 2014 )
Pour utiliser ceci via la syntaxe MVC fluent, donnez simplement un nom à la fonction anonyme edit au-dessus (par exemple, onEdit):
function onEdit(e) {
var fieldName = e.container.find("input").attr("name");
// alternative (if you don't have the name attribute in your editable):
// var columnIndex = this.cellIndex(e.container);
// var fieldName = this.thead.find("th").eq(columnIndex).data("field");
if (!isEditable(fieldName, e.model)) {
this.closeCell(); // prevent editing
}
}
et le référencer comme ceci:
@(Html.Kendo().Grid()
.Name("Grid")
.Events(events => events.Edit("onEdit"))
)
L'inconvénient est que l'éditeur est créé avant le déclenchement de l'événement d'édition, ce qui peut parfois avoir des effets visuels indésirables.
Approche n ° 2
Étendez la grille en surchargeant sa méthode editCell avec une variante qui déclenche un événement beforeEdit; pour que cela fonctionne avec les options de la grille, vous devez également redéfinir la méthode init:
var oEditCell = kendo.ui.Grid.fn.editCell;
var oInit = kendo.ui.Grid.fn.init;
kendo.ui.Grid = kendo.ui.Grid.extend({
init: function () {
oInit.apply(this, arguments);
if (typeof this.options.beforeEdit === "function") {
this.bind("beforeEdit", this.options.beforeEdit.bind(this));
}
},
editCell: function (cell) {
var that = this,
cell = $(cell),
column = that.columns[that.cellIndex(cell)],
model = that._modelForContainer(cell),
event = {
container: cell,
model: model,
field: column.field
};
if (model && this.trigger("beforeEdit", event)) {
// don't edit if prevented in beforeEdit
if (event.isDefaultPrevented()) return;
}
oEditCell.call(this, cell);
}
});
kendo.ui.plugin(kendo.ui.Grid);
puis utilisez-le comme le n ° 1:
$("#grid").kendoGrid({
dataSource: dataSource,
height: "300px",
columns: columns,
editable: true,
beforeEdit: function(e) {
var columnIndex = this.cellIndex(e.container);
var fieldName = this.thead.find("th").eq(columnIndex).data("field");
if (!isEditable(fieldName, e.model)) {
e.preventDefault();
}
}
});
La différence de cette approche est que l'éditeur ne sera pas créé (et concentré) en premier. La méthode beforeEdit utilise la même méthode isEditable de # 1 . Voir un démonstration de cette approche ici }.
Si vous souhaitez utiliser cette approche avec des wrappers MVC mais que vous ne voulez pas/ne pouvez pas étendre GridEventBuilder, vous pouvez toujours lier votre gestionnaire d'événements en JavaScript (place sous l'initialiseur MVC de la grille):
$(function() {
var grid = $("#grid").data("kendoGrid");
grid.bind("beforeEdit", onEdit.bind(grid));
});
Aucune de ces approches n'a fonctionné pour moi. Une implentation très simple ressemble à ceci
edit: function (e) {
e.container.find("input[name='Name']").each(function () { $(this).attr("disabled", "disabled") });
}
Où edit fait partie de la déclaration de la grille de kendo et Name, le nom réel du champ.
Veuillez essayer avec l'extrait de code ci-dessous.
VUE
<script type="text/javascript">
function errorHandler(e) {
if (e.errors) {
var message = "Errors:\n";
$.each(e.errors, function (key, value) {
if ('errors' in value) {
$.each(value.errors, function () {
message += this + "\n";
});
}
});
alert(message);
}
}
function onGridEdit(arg) {
if (arg.container.find("input[name=IsFkEnabled]").length > 0) {
arg.container.find("input[name=IsFkEnabled]").click(function () {
if ($(this).is(":checked") == false) {
}
else {
arg.model.IsFkEnabled = true;
$("#Grid").data("kendoGrid").closeCell(arg.container);
$("#Grid").data("kendoGrid").editCell(arg.container.next());
}
});
}
if (arg.container.find("input[name=FID]").length > 0) {
if (arg.model.IsFkEnabled == false) {
$("#Grid").data("kendoGrid").closeCell(arg.container)
}
}
}
</script>
<div>
@(Html.Kendo().Grid<MvcApplication1.Models.TestModels>()
.Name("Grid")
.Columns(columns =>
{
columns.Bound(p => p.ID);
columns.Bound(p => p.Name);
columns.Bound(p => p.IsFkEnabled);
columns.ForeignKey(p => p.FID, (System.Collections.IEnumerable)ViewData["TestList"], "Value", "Text");
})
.ToolBar(toolBar => toolBar.Save())
.Editable(editable => editable.Mode(GridEditMode.InCell))
.Pageable()
.Sortable()
.Scrollable()
.Filterable()
.Events(e => e.Edit("onGridEdit"))
.DataSource(dataSource => dataSource
.Ajax()
.Batch(true)
.ServerOperation(false)
.Events(events => events.Error("errorHandler"))
.Model(model =>
{
model.Id(p => p.ID);
model.Field(p => p.ID).Editable(false);
})
.Read(read => read.Action("ForeignKeyColumn_Read", "Home"))
.Update(update => update.Action("ForeignKeyColumn_Update", "Home"))
)
)
</div>
MOD&EGRAVE;LE
namespace MvcApplication1.Models
{
public class TestModels
{
public int ID { get; set; }
public string Name { get; set; }
public bool IsFkEnabled { get; set; }
public int FID { get; set; }
}
}
MANETTE
public class HomeController : Controller
{
public ActionResult Index()
{
List<SelectListItem> items = new List<SelectListItem>();
for (int i = 1; i < 6; i++)
{
SelectListItem item = new SelectListItem();
item.Text = "text" + i.ToString();
item.Value = i.ToString();
items.Add(item);
}
ViewData["TestList"] = items;
return View();
}
public ActionResult ForeignKeyColumn_Read([DataSourceRequest] DataSourceRequest request)
{
List<TestModels> models = new List<TestModels>();
for (int i = 1; i < 6; i++)
{
TestModels model = new TestModels();
model.ID = i;
model.Name = "Name" + i;
if (i % 2 == 0)
{
model.IsFkEnabled = true;
}
model.FID = i;
models.Add(model);
}
return Json(models.ToDataSourceResult(request));
}
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult ForeignKeyColumn_Update([DataSourceRequest] DataSourceRequest request, [Bind(Prefix = "models")]IEnumerable<TestModels> tests)
{
if (tests != null && ModelState.IsValid)
{
// Save/Update logic comes here
}
return Json(ModelState.ToDataSourceResult());
}
}
Si vous voulez télécharger la démo, cliquez sur ici .
Une autre approche consiste à utiliser votre propre fonction "editor" pour la définition de colonne, qui fournit soit un élément input, soit un div simple, selon votre condition.
La méthode la plus simple consiste à utiliser l'événement dataBound pour appliquer de manière conditionnelle l'une des classes CSS spéciales aux cellules que la grille ignore pour la modification:
dataBound: function(e) { var colIndex = 1; var rows = this.table.find("tr:not(.k-grouping-row)"); for (var i = 0; i < rows.length; i++) { var row = rows[i]; var model = this.dataItem(row); if (!model.Discontinued) { var cell = $($(row).find("td")[colIndex]); cell.addClass("k-group-cell"); } } },