697 lines
24 KiB
C#
697 lines
24 KiB
C#
using AyCode.Core;
|
|
using AyCode.Core.Enums;
|
|
using AyCode.Core.Helpers;
|
|
using AyCode.Core.Interfaces;
|
|
using AyCode.Core.Loggers;
|
|
using AyCode.Services.Server.SignalRs;
|
|
using AyCode.Services.SignalRs;
|
|
using AyCode.Utils.Extensions;
|
|
using DevExpress.Blazor;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Components.Rendering;
|
|
using System.ComponentModel;
|
|
using System.Reflection;
|
|
using DevExpress.Blazor.Internal;
|
|
|
|
namespace AyCode.Blazor.Components.Components.Grids;
|
|
|
|
public interface IMgGridBase : IGrid
|
|
{
|
|
/// <summary>
|
|
/// Indicates whether any synchronization operation is in progress
|
|
/// </summary>
|
|
bool IsSyncing { get; }
|
|
|
|
/// <summary>
|
|
/// Current edit state of the grid (None, New, Edit)
|
|
/// </summary>
|
|
MgEditState EditState { get; }
|
|
}
|
|
|
|
public abstract class MgGridBase<TSignalRDataSource, TDataItem, TId, TLoggerClient> : DxGrid, IMgGridBase, IAsyncDisposable
|
|
where TSignalRDataSource : AcSignalRDataSource<TDataItem, TId, AcObservableCollection<TDataItem>>
|
|
where TDataItem : class, IId<TId>
|
|
where TId : struct
|
|
where TLoggerClient : AcLoggerBase
|
|
{
|
|
private readonly EqualityComparer<TId> _equalityComparerId = EqualityComparer<TId>.Default;
|
|
private readonly TypeConverter _typeConverterId = TypeDescriptor.GetConverter(typeof(TId));
|
|
|
|
protected bool IsFirstInitializeParameters;
|
|
protected bool IsFirstInitializeParameterCore;
|
|
private bool _isDisposed;
|
|
|
|
private TSignalRDataSource? _dataSource = null!;
|
|
private AcObservableCollection<TDataItem>? _dataSourceParam = [];
|
|
private string _gridLogName;
|
|
|
|
/// <inheritdoc />
|
|
public bool IsSyncing => _dataSource?.IsSyncing ?? false;
|
|
|
|
/// <inheritdoc />
|
|
public MgEditState EditState { get; private set; } = MgEditState.None;
|
|
|
|
[Parameter] public bool ShowInfoPanel { get; set; } = true;
|
|
|
|
private object _focusedDataItem;
|
|
private MgGridInfoPanel<TDataItem>? _infoPanelInstance;
|
|
|
|
public MgGridBase() : base()
|
|
{
|
|
}
|
|
|
|
//protected override RenderFragment<RenderFragment> CreateRootComponent()
|
|
//{
|
|
// System.Diagnostics.Debug.WriteLine($"[MgGridBase] CreateRootComponent - ShowInfoPanel: {ShowInfoPanel}, GridName: {GridName}");
|
|
|
|
// if (!ShowInfoPanel)
|
|
// {
|
|
// // Ha nincs InfoPanel, használjuk az alapértelmezett renderelést
|
|
// System.Diagnostics.Debug.WriteLine("[MgGridBase] Using base CreateRootComponent");
|
|
|
|
// return base.CreateRootComponent();
|
|
// }
|
|
|
|
// // Ha van InfoPanel, akkor splitter-rel burkoljuk be
|
|
// System.Diagnostics.Debug.WriteLine("[MgGridBase] Creating splitter wrapper");
|
|
|
|
// return (RenderFragment<RenderFragment>)(content => (RenderFragment)(builder =>
|
|
// {
|
|
// var seq = 0;
|
|
|
|
// // DxSplitter
|
|
// builder.OpenComponent<DxSplitter>(seq++);
|
|
// builder.AddAttribute(seq++, "Width", "100%");
|
|
// builder.AddAttribute(seq++, "Height", "100%");
|
|
|
|
// // Panes
|
|
// builder.AddAttribute(seq++, "Panes", (RenderFragment)(panesBuilder =>
|
|
// {
|
|
// var paneSeq = 0;
|
|
|
|
// // Bal pane - Grid
|
|
// panesBuilder.OpenComponent<DxSplitterPane>(paneSeq++);
|
|
|
|
// panesBuilder.AddAttribute(paneSeq++, "ChildContent", (RenderFragment)(gridBuilder =>
|
|
// {
|
|
// // A grid eredeti content-jét rendereljük
|
|
// var baseRootComponent = base.CreateRootComponent();
|
|
// baseRootComponent(content)(gridBuilder);
|
|
// }));
|
|
|
|
// panesBuilder.CloseComponent();
|
|
|
|
// // Jobb pane - Egyelőre üres
|
|
// panesBuilder.OpenComponent<DxSplitterPane>(paneSeq++);
|
|
|
|
// panesBuilder.AddAttribute(paneSeq++, "Size", "0px");
|
|
// panesBuilder.AddAttribute(paneSeq++, "MinSize", "0px");
|
|
// panesBuilder.AddAttribute(paneSeq++, "AllowCollapse", true);
|
|
// panesBuilder.AddAttribute(paneSeq++, "Collapsed", true);
|
|
|
|
// panesBuilder.AddAttribute(paneSeq++, "ChildContent", (RenderFragment)(infoPanelBuilder =>
|
|
// {
|
|
// infoPanelBuilder.OpenElement(0, "div");
|
|
// infoPanelBuilder.AddAttribute(1, "style", "padding: 1rem;");
|
|
// infoPanelBuilder.AddContent(2, "Info Panel - Coming soon...");
|
|
// infoPanelBuilder.CloseElement();
|
|
// }));
|
|
|
|
// panesBuilder.CloseComponent();
|
|
|
|
// }));
|
|
|
|
// builder.CloseComponent();
|
|
// }));
|
|
//}
|
|
|
|
protected override void BuildRenderTree(RenderTreeBuilder builder)
|
|
{
|
|
if (!ShowInfoPanel)
|
|
{
|
|
base.BuildRenderTree(builder);
|
|
return;
|
|
}
|
|
|
|
var seq = 0;
|
|
|
|
builder.OpenComponent<DxSplitter>(seq++);
|
|
builder.AddAttribute(seq++, "Width", "100%");
|
|
builder.AddAttribute(seq++, "Height", "100%");
|
|
|
|
builder.AddAttribute(seq++, "Panes", (RenderFragment)(panesBuilder =>
|
|
{
|
|
var paneSeq = 0;
|
|
|
|
// Left pane - Grid
|
|
panesBuilder.OpenComponent<DxSplitterPane>(paneSeq++);
|
|
panesBuilder.AddAttribute(paneSeq++, "ChildContent", (RenderFragment)(gridBuilder =>
|
|
{
|
|
base.BuildRenderTree(gridBuilder);
|
|
}));
|
|
panesBuilder.CloseComponent();
|
|
|
|
// Right pane - InfoPanel
|
|
panesBuilder.OpenComponent<DxSplitterPane>(paneSeq++);
|
|
panesBuilder.AddAttribute(paneSeq++, "Size", "350px");
|
|
panesBuilder.AddAttribute(paneSeq++, "MinSize", "300px");
|
|
panesBuilder.AddAttribute(paneSeq++, "MaxSize", "800px");
|
|
panesBuilder.AddAttribute(paneSeq++, "AllowCollapse", true);
|
|
|
|
panesBuilder.AddAttribute(paneSeq++, "ChildContent", (RenderFragment)(infoPanelBuilder =>
|
|
{
|
|
var infoPanelSeq = 0;
|
|
infoPanelBuilder.OpenComponent<MgGridInfoPanel<TDataItem>>(infoPanelSeq++);
|
|
infoPanelBuilder.AddComponentReferenceCapture(infoPanelSeq++, instance =>
|
|
{
|
|
_infoPanelInstance = (MgGridInfoPanel<TDataItem>)instance;
|
|
});
|
|
infoPanelBuilder.CloseComponent();
|
|
}));
|
|
|
|
panesBuilder.CloseComponent();
|
|
}));
|
|
|
|
builder.CloseComponent();
|
|
}
|
|
|
|
//protected override Task RaiseFocusedRowChangedAsync(GridFocusedRowChangedEventArgsBase args)
|
|
//{
|
|
// _focusedDataItem = args.DataItem;
|
|
// InvokeAsync(StateHasChanged);
|
|
// return base.RaiseFocusedRowChangedAsync(args);
|
|
//}
|
|
|
|
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]
|
|
public string? FilterText
|
|
{
|
|
get => _filterText;
|
|
set
|
|
{
|
|
_filterText = value;
|
|
|
|
if (_dataSource != null && _dataSource.FilterText != value)
|
|
{
|
|
_dataSource.FilterText = value;
|
|
ReloadDataSourceAsync().Forget();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Parameter] public AcSignalRClientBase SignalRClient { get; set; }
|
|
|
|
[Parameter] public int GetAllMessageTag { get; set; }
|
|
[Parameter] public int GetItemMessageTag { get; set; }
|
|
[Parameter] public int AddMessageTag { get; set; }
|
|
[Parameter] public int UpdateMessageTag { get; set; }
|
|
[Parameter] public int RemoveMessageTag { get; set; }
|
|
|
|
protected new EventCallback<GridDataItemDeletingEventArgs> DataItemDeleting { get; set; }
|
|
[Parameter] public EventCallback<GridDataItemDeletingEventArgs> OnGridItemDeleting { get; set; }
|
|
|
|
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; }
|
|
|
|
protected new EventCallback<GridFocusedRowChangedEventArgs> FocusedRowChanged { get; set; }
|
|
[Parameter] public EventCallback<GridFocusedRowChangedEventArgs> OnGridFocusedRowChanged { get; set; }
|
|
|
|
[Parameter] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }
|
|
[Parameter] public EventCallback<GridDataItemChangingEventArgs<TDataItem>> OnGridItemChanging { get; set; }
|
|
|
|
/// <summary>
|
|
/// After the server has responded!
|
|
/// </summary>
|
|
[Parameter]
|
|
public EventCallback<GridDataItemChangedEventArgs<TDataItem>> OnGridItemChanged { get; set; }
|
|
|
|
[Parameter]
|
|
[DefaultValue(null)]
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "BL0007:Component parameters should be auto properties", Justification = "<Pending>")]
|
|
public IList<TDataItem> DataSource
|
|
{
|
|
get
|
|
{
|
|
if (_dataSource == null && Data != null)
|
|
{
|
|
Logger.Error($"{_gridLogName} Use the DataSource parameter instead of Data!");
|
|
throw new NullReferenceException($"{_gridLogName} Use the DataSource parameter instead of Data!");
|
|
}
|
|
|
|
return _dataSource!;
|
|
}
|
|
set
|
|
{
|
|
_dataSourceParam = value as AcObservableCollection<TDataItem>;
|
|
|
|
if (_dataSource != null) // && _dataSourceParam is List<TDataItem> workingReferenceList)
|
|
{
|
|
SetWorkingReferenceList(_dataSourceParam);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetWorkingReferenceList(AcObservableCollection<TDataItem>? referenceList)
|
|
{
|
|
_dataSource?.SetWorkingReferenceList(referenceList);
|
|
|
|
SetGridData(referenceList);
|
|
}
|
|
|
|
public void SetGridData(object? data)
|
|
{
|
|
if (_isDisposed) return;
|
|
if (ReferenceEquals(Data, data)) return;
|
|
|
|
BeginUpdate();
|
|
Data = data;
|
|
EndUpdate();
|
|
}
|
|
|
|
protected override async Task OnInitializedAsync()
|
|
{
|
|
if (Logger == null)
|
|
throw new NullReferenceException($"[{GetType().Name}] Logger == null");
|
|
|
|
if (SignalRClient == null)
|
|
{
|
|
Logger.Error($"[{GetType().Name}] SignalRClient == null");
|
|
throw new NullReferenceException($"[{GetType().Name}] SignalRClient == null");
|
|
}
|
|
|
|
var crudTags = new SignalRCrudTags(GetAllMessageTag, GetItemMessageTag, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
|
|
|
|
_dataSource = (TSignalRDataSource)Activator.CreateInstance(typeof(TSignalRDataSource), SignalRClient, crudTags, ContextIds)!;
|
|
_dataSource.FilterText = FilterText;
|
|
//_dataSource = new SignalRDataSource<TDataItem>(SignalRClient, crudTags, ContextIds) { FilterText = FilterText };
|
|
|
|
SetGridData(_dataSource.GetReferenceInnerList());
|
|
|
|
_dataSource.OnDataSourceLoaded += OnDataSourceLoaded;
|
|
_dataSource.OnDataSourceItemChanged += OnDataSourceItemChanged;
|
|
_dataSource.OnSyncingStateChanged += OnDataSourceSyncingStateChanged;
|
|
|
|
await base.OnInitializedAsync();
|
|
}
|
|
|
|
private void OnDataSourceSyncingStateChanged(bool isSyncing)
|
|
{
|
|
if (_isDisposed) return;
|
|
|
|
// Forward the event to external subscribers
|
|
//OnSyncingStateChanged?.Invoke(isSyncing);
|
|
|
|
// Trigger UI update
|
|
InvokeAsync(StateHasChanged);
|
|
}
|
|
|
|
private async Task OnDataSourceItemChanged(ItemChangedEventArgs<TDataItem> args)
|
|
{
|
|
if (_isDisposed) return;
|
|
if (args.TrackingState is TrackingState.GetAll or TrackingState.None) return;
|
|
|
|
Logger.Debug($"{_gridLogName} OnDataSourceItemChanged; trackingState: {args.TrackingState}");
|
|
|
|
var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, args.Item, args.TrackingState);
|
|
await OnGridItemChanged.InvokeAsync(changedEventArgs);
|
|
|
|
if (!changedEventArgs.CancelStateChangeInvoke && !_isDisposed)
|
|
{
|
|
//BeginUpdate();
|
|
await InvokeAsync(StateHasChanged); //TODO: bezárja a DetailRow-t! pl: az email-nél IsReaded=true update... - J.
|
|
//EndUpdate();
|
|
}
|
|
}
|
|
|
|
private async Task OnDataSourceLoaded()
|
|
{
|
|
if (_isDisposed) return;
|
|
|
|
Logger.Debug($"{_gridLogName} OnDataSourceLoaded; Count: {_dataSource?.Count}");
|
|
|
|
SetGridData(_dataSource!.GetReferenceInnerList());
|
|
|
|
if (!_isDisposed)
|
|
{
|
|
await OnDataSourceChanged.InvokeAsync(_dataSource);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
|
|
protected override async Task OnAfterRenderAsync(bool firstRender)
|
|
{
|
|
if (firstRender)
|
|
{
|
|
if (_dataSource == null) return;
|
|
|
|
if (_dataSourceParam != null) await _dataSource.LoadDataSource(_dataSourceParam, true, true);
|
|
else _dataSource.LoadDataSourceAsync(true).Forget();
|
|
}
|
|
|
|
await base.OnAfterRenderAsync(firstRender);
|
|
}
|
|
|
|
private void SetNewId(TDataItem dataItem)
|
|
{
|
|
//TODO: int !!! - J.
|
|
if (dataItem.Id is Guid)
|
|
{
|
|
dataItem.Id = (TId)(_typeConverterId.ConvertTo(Guid.NewGuid(), typeof(TId)))!;
|
|
}
|
|
else if (dataItem.Id is int)
|
|
{
|
|
var newId = -1 * AcDomain.NextUniqueInt32;
|
|
dataItem.Id = (TId)(_typeConverterId.ConvertTo(newId, typeof(TId)))!;
|
|
}
|
|
}
|
|
|
|
public Task AddDataItem(TDataItem dataItem)
|
|
{
|
|
if (!HasIdValue(dataItem)) SetNewId(dataItem);
|
|
return _dataSource.Add(dataItem, true);
|
|
}
|
|
|
|
public Task AddDataItemAsync(TDataItem dataItem)
|
|
{
|
|
if (!HasIdValue(dataItem)) SetNewId(dataItem);
|
|
_dataSource.Add(dataItem);
|
|
|
|
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);
|
|
|
|
protected virtual 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;
|
|
}
|
|
|
|
// Set edit state
|
|
EditState = e.IsNew ? MgEditState.New : MgEditState.Edit;
|
|
|
|
await OnGridCustomizeEditModel.InvokeAsync(e);
|
|
|
|
// Frissítjük az InfoPanel-t edit módba - itt az EditModel már elérhető
|
|
if (ShowInfoPanel && _infoPanelInstance != null)
|
|
{
|
|
_infoPanelInstance.SetEditMode(editModel);
|
|
}
|
|
}
|
|
|
|
private async Task OnEditStart(GridEditStartEventArgs e)
|
|
{
|
|
await OnGridEditStart.InvokeAsync(e);
|
|
// Az InfoPanel-t és az EditMode-ot a CustomizeEditModel-ben frissítjük, mert ott az EditModel már elérhető
|
|
}
|
|
|
|
protected virtual async Task OnFocusedRowChanged(GridFocusedRowChangedEventArgs e)
|
|
{
|
|
_focusedDataItem = e.DataItem;
|
|
|
|
if (ShowInfoPanel && _infoPanelInstance != null && e.DataItem is TDataItem dataItem)
|
|
{
|
|
_infoPanelInstance.RefreshData(this, dataItem, e.VisibleIndex);
|
|
}
|
|
|
|
await OnGridFocusedRowChanged.InvokeAsync(e);
|
|
}
|
|
|
|
private async Task OnItemSaving(GridEditModelSavingEventArgs e)
|
|
{
|
|
var dataItem = (e.EditModel as TDataItem)!;
|
|
|
|
if (e.IsNew)
|
|
{
|
|
if (!HasIdValue(dataItem)) SetNewId(dataItem);
|
|
}
|
|
|
|
var logText = e.IsNew ? "add" : "update";
|
|
Logger.Debug($"{_gridLogName} OnItemSaving {logText}; Id: {dataItem.Id}");
|
|
|
|
await OnGridEditModelSaving.InvokeAsync(e);
|
|
|
|
if (e.Cancel)
|
|
{
|
|
Logger.Debug($"{_gridLogName} OnItemSaving {logText} canceled; Id: {dataItem.Id}");
|
|
return;
|
|
}
|
|
|
|
if (e.IsNew)
|
|
{
|
|
if (EditNewRowPosition is GridEditNewRowPosition.FixedOnTop or GridEditNewRowPosition.Top) await AddDataItemAsync(dataItem);
|
|
else await InsertDataItemAsync(0, dataItem);
|
|
}
|
|
else await UpdateDataItemAsync(dataItem);
|
|
|
|
// Kilépés edit módból
|
|
EditState = MgEditState.None;
|
|
|
|
if (ShowInfoPanel && _infoPanelInstance != null)
|
|
{
|
|
_infoPanelInstance.ClearEditMode();
|
|
}
|
|
}
|
|
|
|
private async Task OnEditCanceling(GridEditCancelingEventArgs e)
|
|
{
|
|
// Kilépés edit módból
|
|
EditState = MgEditState.None;
|
|
|
|
if (ShowInfoPanel && _infoPanelInstance != null)
|
|
{
|
|
_infoPanelInstance.ClearEditMode();
|
|
}
|
|
}
|
|
|
|
private Task SaveChangesToServerAsync()
|
|
{
|
|
try
|
|
{
|
|
return _dataSource.SaveChangesAsync();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error($"{_gridLogName} SaveChangesToServerAsync->SaveChangesAsync error!", ex);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private async Task<bool> SaveChangesToServer()
|
|
{
|
|
var result = false;
|
|
|
|
try
|
|
{
|
|
var unsavedItems = await _dataSource.SaveChanges();
|
|
|
|
if (!(result = unsavedItems.Count == 0))
|
|
Logger.Error($"{_gridLogName} SaveChangesToServer->SaveChanges error! unsavedCount: {unsavedItems.Count}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error($"{_gridLogName} OnItemSaving", ex);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task OnItemDeleting(GridDataItemDeletingEventArgs e)
|
|
{
|
|
Logger.Debug($"{_gridLogName} OnItemDeleting");
|
|
|
|
await OnGridItemDeleting.InvokeAsync(e);
|
|
|
|
if (e.Cancel)
|
|
{
|
|
Logger.Debug($"{_gridLogName} OnItemDeleting canceled");
|
|
return;
|
|
}
|
|
|
|
var dataItem = (e.DataItem as TDataItem)!;
|
|
await RemoveDataItem(dataItem);
|
|
}
|
|
|
|
private void OnCustomizeElement(GridCustomizeElementEventArgs e)
|
|
{
|
|
if (e.ElementType == GridElementType.DetailCell)
|
|
{
|
|
e.Style = "padding: 0.5rem; opacity: 0.75";
|
|
}
|
|
else if (false && e.ElementType == GridElementType.DataCell && e.Column.Name == nameof(IId<TId>.Id))
|
|
{
|
|
e.Column.Visible = AcDomain.IsDeveloperVersion;
|
|
e.Column.ShowInColumnChooser = AcDomain.IsDeveloperVersion;
|
|
}
|
|
}
|
|
|
|
protected override async Task SetParametersAsyncCore(ParameterView parameters)
|
|
{
|
|
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.FocusedRowChanged = EventCallback.Factory.Create<GridFocusedRowChangedEventArgs>(this, OnFocusedRowChanged);
|
|
base.EditStart = EventCallback.Factory.Create<GridEditStartEventArgs>(this, OnEditStart);
|
|
base.EditCanceling = EventCallback.Factory.Create<GridEditCancelingEventArgs>(this, OnEditCanceling);
|
|
|
|
CustomizeElement += OnCustomizeElement;
|
|
|
|
//ShowFilterRow = true;
|
|
//PageSize = 4;
|
|
//ShowGroupPanel = true;
|
|
//AllowSort = false;
|
|
|
|
TextWrapEnabled = false;
|
|
AllowSelectRowByClick = true;
|
|
HighlightRowOnHover = true;
|
|
AutoCollapseDetailRow = true;
|
|
AutoExpandAllGroupRows = false;
|
|
|
|
IsFirstInitializeParameterCore = true;
|
|
}
|
|
}
|
|
|
|
|
|
protected override void OnParametersSet()
|
|
{
|
|
if (!IsFirstInitializeParameters)
|
|
{
|
|
if (GridName.IsNullOrWhiteSpace()) GridName = $"{typeof(TDataItem).Name}Grid";
|
|
_gridLogName = $"[{GridName}]";
|
|
|
|
IsFirstInitializeParameters = true;
|
|
}
|
|
|
|
base.OnParametersSet();
|
|
}
|
|
|
|
//public Task AddDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Add);
|
|
|
|
public Task UpdateDataItem(TDataItem dataItem) => _dataSource.Update(dataItem, true);
|
|
|
|
public Task UpdateDataItemAsync(TDataItem dataItem)
|
|
{
|
|
_dataSource.Update(dataItem, false);
|
|
return SaveChangesToServerAsync();
|
|
}
|
|
//public Task UpdateDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Update);
|
|
|
|
public Task AddOrUpdateDataItem(TDataItem dataItem) => _dataSource.AddOrUpdate(dataItem, true);
|
|
|
|
public Task RemoveDataItem(TDataItem dataItem) => _dataSource.Remove(dataItem, true);
|
|
//public Task RemoveDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Remove);
|
|
|
|
public Task RemoveDataItem(TId id) => RemoveDataItem(id, RemoveMessageTag);
|
|
|
|
public Task RemoveDataItem(TId id, int messageTag)
|
|
{
|
|
return _dataSource.Remove(id, true);
|
|
}
|
|
|
|
public Task ReloadDataSourceAsync()
|
|
{
|
|
return _dataSource.LoadDataSourceAsync(false);
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
if (_isDisposed) return;
|
|
_isDisposed = true;
|
|
|
|
// Unsubscribe from events to prevent callbacks to disposed component
|
|
if (_dataSource != null)
|
|
{
|
|
_dataSource.OnDataSourceLoaded -= OnDataSourceLoaded;
|
|
_dataSource.OnDataSourceItemChanged -= OnDataSourceItemChanged;
|
|
_dataSource.OnSyncingStateChanged -= OnDataSourceSyncingStateChanged;
|
|
}
|
|
|
|
CustomizeElement -= OnCustomizeElement;
|
|
|
|
// Dispose base if it implements IAsyncDisposable
|
|
if (this is IAsyncDisposable asyncDisposable && asyncDisposable != this)
|
|
{
|
|
await asyncDisposable.DisposeAsync();
|
|
}
|
|
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
|
|
public class GridDataItemChangingEventArgs<TDataItem> : GridDataItemChangedEventArgs<TDataItem> where TDataItem : class
|
|
{
|
|
internal GridDataItemChangingEventArgs(IMgGridBase grid, TDataItem dataItem, TrackingState trackingState) : base(grid, dataItem, trackingState)
|
|
{
|
|
}
|
|
|
|
public bool IsCanceled { get; set; }
|
|
}
|
|
|
|
public class GridDataItemChangedEventArgs<TDataItem> where TDataItem : class
|
|
{
|
|
internal GridDataItemChangedEventArgs(IMgGridBase grid, TDataItem dataItem, TrackingState trackingState)
|
|
{
|
|
Grid = grid ?? throw new ArgumentNullException(nameof(grid));
|
|
DataItem = dataItem;
|
|
TrackingState = trackingState;
|
|
}
|
|
|
|
public IMgGridBase Grid { get; }
|
|
public TDataItem DataItem { get; }
|
|
public TrackingState TrackingState { get; }
|
|
public bool CancelStateChangeInvoke { get; set; }
|
|
} |