diff --git a/AyCode.Blazor.Components/Components/Grids/MgGridBase.cs b/AyCode.Blazor.Components/Components/Grids/MgGridBase.cs
index 8aee83b..8844764 100644
--- a/AyCode.Blazor.Components/Components/Grids/MgGridBase.cs
+++ b/AyCode.Blazor.Components/Components/Grids/MgGridBase.cs
@@ -9,6 +9,7 @@ using AyCode.Utils.Extensions;
 using DevExpress.Blazor;
 using Microsoft.AspNetCore.Components;
 using System.ComponentModel;
+using System.Reflection;
 
 namespace AyCode.Blazor.Components.Components.Grids;
 
@@ -18,14 +19,17 @@ public interface IMgGridBase : IGrid
 }
 
 public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClient> : DxGrid, IMgGridBase
-    where TSignalRDataSource : AcSignalRDataSource<TDataItem, TId, List<TDataItem>> 
-    where TDataItem : class, IId<TId> 
-    where TId : struct 
+    where TSignalRDataSource : AcSignalRDataSource<TDataItem, TId, List<TDataItem>>
+    where TDataItem : class, IId<TId>
+    where TId : struct
     where TLoggerClient : AcLoggerBase
 {
-    private readonly EqualityComparer<TId> _equalityComparer = EqualityComparer<TId>.Default;
+    private readonly EqualityComparer<TId> _equalityComparerId = EqualityComparer<TId>.Default;
+    private readonly TypeConverter _typeConverterId = TypeDescriptor.GetConverter(typeof(TId));
 
     protected bool IsFirstInitializeParameters;
+    protected bool IsFirstInitializeParameterCore;
+
     private TSignalRDataSource _dataSource = null!;
     private List<TDataItem> _dataSourceParam = [];
     private string _gridLogName;
@@ -34,13 +38,19 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
     {
     }
 
-    protected bool HasIdValue(TDataItem dataItem) => !_equalityComparer.Equals(dataItem.Id, default);//dataItem.Id.IsNullOrEmpty();
-    protected bool IdEquals(TId id1, TId id2) => _equalityComparer.Equals(id1, id2);
+    protected bool HasIdValue(TDataItem dataItem) => HasIdValue(dataItem.Id);
+    protected bool HasIdValue(TId id) => !_equalityComparerId.Equals(id, default);
+    protected bool IdEquals(TId id1, TId id2) => _equalityComparerId.Equals(id1, id2);
 
     [Parameter] public TLoggerClient Logger { get; set; }
     [Parameter] public string GridName { get; set; }
+    [Parameter] public IId<TId>? ParentDataItem { get; set; }
+    [Parameter] public string? KeyFieldNameToParentId { get; set; }
     [Parameter] public object[]? ContextIds { get; set; }
 
+    public bool IsMasterGrid => ParentDataItem == null;
+    protected PropertyInfo? KeyFieldPropertyInfoToParent;
+
     private string? _filterText = null;
 
     [Parameter]
@@ -73,6 +83,12 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
     protected new EventCallback<GridEditModelSavingEventArgs> EditModelSaving { get; set; }
     [Parameter] public EventCallback<GridEditModelSavingEventArgs> OnGridEditModelSaving { get; set; }
 
+    protected new EventCallback<GridEditStartEventArgs> EditStart { get; set; }
+    [Parameter] public EventCallback<GridEditStartEventArgs> OnGridEditStart { get; set; }
+
+    protected new EventCallback<GridCustomizeEditModelEventArgs> CustomizeEditModel { get; set; }
+    [Parameter] public EventCallback<GridCustomizeEditModelEventArgs> OnGridCustomizeEditModel { get; set; }
+
     [Parameter] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }
     [Parameter] public EventCallback<GridDataItemChangingEventArgs<TDataItem>> OnGridItemChanging { get; set; }
 
@@ -101,7 +117,7 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
         {
             _dataSourceParam = value as List<TDataItem>;
 
-            if (_dataSource != null!)// && _dataSourceParam is List<TDataItem> workingReferenceList)
+            if (_dataSource != null!) // && _dataSourceParam is List<TDataItem> workingReferenceList)
                 _dataSource.SetWorkingReferenceList(_dataSourceParam);
         }
     }
@@ -168,10 +184,18 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
         await base.OnAfterRenderAsync(firstRender);
     }
 
-    private static void SetNewId(TDataItem dataItem)
+    private void SetNewId(TDataItem dataItem)
     {
         //TODO: int !!! - J.
-        if (dataItem.Id is Guid) TypeDescriptor.GetConverter(Guid.NewGuid()).ConvertTo(dataItem.Id, typeof(TId));
+        if (dataItem.Id is Guid)
+        {
+            dataItem.Id = (TId)(_typeConverterId.ConvertTo(Guid.NewGuid(), typeof(TId)))!;
+        }
+        else if (dataItem.Id is int)
+        {
+            var newId = -1 * (new Random().Next());
+            dataItem.Id = (TId)(_typeConverterId.ConvertTo(newId, typeof(TId)))!;
+        }
     }
 
     public Task AddDataItem(TDataItem dataItem)
@@ -188,11 +212,80 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
         return SaveChangesToServerAsync();
     }
 
+    public Task InsertDataItem(int index, TDataItem dataItem)
+    {
+        if (!HasIdValue(dataItem)) SetNewId(dataItem);
+        return _dataSource.Insert(index, dataItem, true);
+    }
+
+    public Task InsertDataItemAsync(int index, TDataItem dataItem)
+    {
+        if (!HasIdValue(dataItem)) SetNewId(dataItem);
+        _dataSource.Insert(index, dataItem);
+
+        return SaveChangesToServerAsync();
+    }
+
+    protected PropertyInfo? GetDataItemPropertyInfo(string propertyName)
+        => typeof(TDataItem).GetProperty(propertyName);
+    
+    private async Task OnCustomizeEditModel(GridCustomizeEditModelEventArgs e)
+    {
+        var editModel = (e.EditModel as TDataItem)!;
+
+        if (e.IsNew)
+        {
+            if (!HasIdValue(editModel)) SetNewId(editModel);
+
+            if (ParentDataItem != null && !KeyFieldNameToParentId.IsNullOrWhiteSpace())
+            {
+                KeyFieldPropertyInfoToParent ??= GetDataItemPropertyInfo(KeyFieldNameToParentId);
+                KeyFieldPropertyInfoToParent!.SetValue(editModel, ParentDataItem.Id);
+            }
+
+            e.EditModel = editModel;
+        }
+
+        await OnGridCustomizeEditModel.InvokeAsync(e);
+    }
+    
+    private async Task OnEditStart(GridEditStartEventArgs e)
+    {
+        var dataItem = (e.DataItem as TDataItem)!;
+
+        await OnGridEditStart.InvokeAsync(e);
+    }
+
+    //void Grid_CustomizeEditModel(GridCustomizeEditModelEventArgs e)
+    //{
+    //    var model = e.EditModel as EditableWorkOrder;
+    //    if (model == null)
+    //    {
+    //        model = new EditableWorkOrder();
+
+    //        model.WorkOrderNum = "123";
+    //        model.Description = "hey";
+
+    //        e.EditModel = model;
+    //    }
+    //}
     private async Task OnItemSaving(GridEditModelSavingEventArgs e)
     {
         var dataItem = (e.EditModel as TDataItem)!;
 
-        if (e.IsNew && !HasIdValue(dataItem)) SetNewId(dataItem);
+        if (e.IsNew)
+        {
+            if (!HasIdValue(dataItem)) SetNewId(dataItem);
+
+            //if (ParentDataItem != null && !KeyFieldNameToParentId.IsNullOrWhiteSpace())
+            //{
+            //    Type examType = typeof(TDataItem);
+
+            //    // Change the static property value.
+            //    PropertyInfo piShared = examType.GetProperty(KeyFieldNameToParentId);
+            //    piShared.SetValue(dataItem, ParentDataItem.Id);
+            //}
+        }
 
         var logText = e.IsNew ? "add" : "update";
         Logger.Debug($"{_gridLogName} OnItemSaving {logText}; Id: {dataItem.Id}");
@@ -205,7 +298,11 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
             return;
         }
 
-        if (e.IsNew) await AddDataItemAsync(dataItem);
+        if (e.IsNew)
+        {
+            if (EditNewRowPosition is GridEditNewRowPosition.FixedOnTop or GridEditNewRowPosition.Top) await InsertDataItemAsync(0, dataItem);
+            else await AddDataItemAsync(dataItem);
+        }
         else await UpdateDataItemAsync(dataItem);
 
         //var equalityComparer = EqualityComparer<TId>.Default;
@@ -277,15 +374,19 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
         }
     }
 
-    protected override Task SetParametersAsyncCore(ParameterView parameters)
+    protected override async Task SetParametersAsyncCore(ParameterView parameters)
     {
-        if (!IsFirstInitializeParameters)
+        await base.SetParametersAsyncCore(parameters);
+
+        if (!IsFirstInitializeParameterCore)
         {
             //if (typeof(TDataItem) is IId<TId> || typeof(TDataItem) is IId<TId>)
             KeyFieldName = "Id";
 
             base.DataItemDeleting = EventCallback.Factory.Create<GridDataItemDeletingEventArgs>(this, OnItemDeleting);
             base.EditModelSaving = EventCallback.Factory.Create<GridEditModelSavingEventArgs>(this, OnItemSaving);
+            base.CustomizeEditModel = EventCallback.Factory.Create<GridCustomizeEditModelEventArgs>(this, OnCustomizeEditModel);
+            base.EditStart = EventCallback.Factory.Create<GridEditStartEventArgs>(this, OnEditStart);
 
             CustomizeElement += OnCustomizeElement;
 
@@ -310,21 +411,22 @@ public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClie
             //    idColumn.Visible = !AcDomain.IsDeveloperVersion;
             //}
 
-            IsFirstInitializeParameters = true;
+            IsFirstInitializeParameterCore = true;
         }
-
-        return base.SetParametersAsyncCore(parameters);
     }
 
 
     protected override void OnParametersSet()
     {
+        if (!IsFirstInitializeParameters)
+        {
+            if (GridName.IsNullOrWhiteSpace()) GridName = $"{typeof(TDataItem).Name}Grid";
+            _gridLogName = $"[{GridName}]";
+
+            IsFirstInitializeParameters = true;
+        }
+
         base.OnParametersSet();
-
-        if (GridName.IsNullOrWhiteSpace()) GridName = $"{typeof(TDataItem).Name}Grid";
-
-        _gridLogName = $"[{GridName}]";
-
     }
 
     //public Task AddDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Add);