TourIAm/TIAMSharedUI/Shared/Components/Grids/TiamGrid.cs

using System.ComponentModel;
using System.Data.Common;
using AyCode.Core;
using AyCode.Core.Enums;
using AyCode.Core.Extensions;
using AyCode.Core.Helpers;
using AyCode.Core.Interfaces;
using AyCode.Interfaces.Entities;
using AyCode.Services.SignalRs;
using AyCode.Utils.Extensions;
using DevExpress.Blazor;
using DevExpress.Blazor.Internal;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using TIAM.Services;
using TIAMWebApp.Shared.Application.Services;
using TIAMWebApp.Shared.Application.Utility;

namespace TIAMSharedUI.Shared.Components.Grids
{
    public class GridDataItemChangingEventArgs<TDataItem> : GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
    {
        internal GridDataItemChangingEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState) : base(grid, dataItem, trackingState)
        {
        }

        public bool IsCanceled { get; set; }
    }

    public class GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
    {
        internal GridDataItemChangedEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState)
        {
            Grid = grid;
            DataItem = dataItem;
            TrackingState = trackingState;
        }

        public TiamGrid<TDataItem> Grid { get; }
        public TDataItem DataItem { get; }
        public TrackingState TrackingState { get; }
    }

    public class TiamGrid<TDataItem> : DxGrid where TDataItem : class, IId<Guid>
    {
        protected bool IsFirstInitializeParameters;
        private SignalRDataSource<TDataItem> _dataSource = null!;
        private IList<TDataItem> _dataSourceParam = [];
        private string _gridLogName;

        public TiamGrid() : base()
        {
        }

        [Parameter] public LoggerClient Logger { get; set; }
        [Parameter] public string GridName { get; set; }
        [Parameter] public Guid? ContextId { get; set; }
        [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; }

        [Parameter] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }
        [Parameter] public EventCallback<GridDataItemChangingEventArgs<TDataItem>> OnGridItemChanging { get; set; }
        /// <summary>
        /// After server response!
        /// </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
            {
                if (value == null) return;
                _dataSourceParam = value;

                //bool equals;

                //if ((equals = Equals(_dataSource, value)) == false)
                //{
                //    if (value is SignalRDataSource<TDataItem> dataSource) 
                //        _dataSource = dataSource;
                //    else
                //    {
                //        var crudTags = new SignalRCrudTags(GetAllMessageTag, SignalRTags.None, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
                //        _dataSource = new SignalRDataSource<TDataItem>(value, SignalRClient, crudTags, ContextId);
                //    }
                //}

                //Data = _dataSource;
                //if (!equals) OnDataSourceChanged.InvokeAsync(_dataSource);
            }
        }

        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, SignalRTags.None, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
            _dataSource = new SignalRDataSource<TDataItem>(SignalRClient, crudTags, ContextId);
            
            Data = _dataSource;

            _dataSource.OnDataSourceLoaded += OnDataSourceLoaded;
            _dataSource.OnDataSourceItemChanged += OnDataSourceItemChanged;

            await base.OnInitializedAsync();
        }

        private Task OnDataSourceItemChanged(ItemChangedEventArgs<TDataItem> args)
        {
            if (args.TrackingState is TrackingState.GetAll or TrackingState.None) return Task.CompletedTask;

            Logger.Info($"{_gridLogName} OnItemLoaded; trackingState: {args.TrackingState}");

            var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, args.Item, args.TrackingState);
            return OnGridItemChanged.InvokeAsync(changedEventArgs);
        }

        private Task OnDataSourceLoaded()
        {
            Logger.Info($"{_gridLogName} OnDataSourceLoaded");
            
            Reload();
            return OnDataSourceChanged.InvokeAsync(_dataSource);
        }

        protected override async Task OnAfterRenderAsync(bool firstRender)
        {
            await base.OnAfterRenderAsync(firstRender);

            if (firstRender)
            {
                if (_dataSourceParam.Count > 0) await _dataSource.LoadDataSource(_dataSourceParam);
                else _dataSource.LoadDataSourceAsync(true).Forget();
            }
        }

        public Task AddDataItem(TDataItem dataItem) => AddDataItem(dataItem, AddMessageTag);
        public Task AddDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Add);

        public Task UpdateDataItem(TDataItem dataItem) => UpdateDataItem(dataItem, UpdateMessageTag);
        public Task UpdateDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Update);

        public Task RemoveDataItem(TDataItem dataItem) => RemoveDataItem(dataItem, RemoveMessageTag);
        public Task RemoveDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Remove);

        public Task RemoveDataItem(Guid id) => RemoveDataItem(id, RemoveMessageTag);

        public async Task RemoveDataItem(Guid id, int messageTag)
        {
            var dataItem = _dataSource.FirstOrDefault(x => x.Id == id);
            if (dataItem != null)
            {
                _dataSource.Remove(dataItem);
                await _dataSource.SaveChanges();
                //await RemoveDataItem(dataItem);
            }

            await InvokeAsync(StateHasChanged);
        }

        private async Task OnItemSaving(GridEditModelSavingEventArgs e)
        {
            var dataItem = (e.EditModel as TDataItem)!;

            if (e.IsNew && dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();

            var logText = e.IsNew ? "add" : "update";
            Logger.Info($"{_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) _dataSource.SetTrackingStateToUpdate(dataItem);
            else
            {
                if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();
                _dataSource.Add(dataItem);
            }

            try
            {
                var unsavedItems = await _dataSource.SaveChanges();

                if (unsavedItems.Count > 0)
                    Logger.Error($"OnItemSaving->TrySaveChanges error! unsavedCount: {unsavedItems.Count}");
            }
            catch (Exception ex)
            {
                Logger.Error($"{_gridLogName} OnItemSaving", ex);
            }
        }

        private async Task OnItemDeleting(GridDataItemDeletingEventArgs e)
        {
            Logger.Info($"{_gridLogName} OnItemDeleting");

            await OnGridItemDeleting.InvokeAsync(e);

            if (e.Cancel)
            {
                Logger.Debug($"{_gridLogName} OnItemDeleting canceled");
                return;
            }

            var dataItem = (e.DataItem as TDataItem)!;
            _dataSource.Remove(dataItem);

            var unsavedItems = await _dataSource.SaveChanges();
            if (unsavedItems.Count > 0)
                Logger.Error($"OnItemDeleting->TrySaveChanges error! unsavedCount: {unsavedItems.Count}");
        }

        protected virtual async Task PostDataToServerAsync(TDataItem dataItem, int messageTag, TrackingState trackingState)
        {
            return;

            var changingEventArgs = new GridDataItemChangingEventArgs<TDataItem>(this, dataItem, trackingState);
            await OnGridItemChanging.InvokeAsync(changingEventArgs);

            if (changingEventArgs.IsCanceled)
            {
                Logger.Debug($"{_gridLogName} OnDataItemChanging canceled");
                return;
            }

            if (messageTag == 0) return;

            Logger.Info($"{_gridLogName} PostDataToServerAsync called; transferId " + dataItem.Id);

            if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();

            _dataSource.UpdateCollection(dataItem, trackingState == TrackingState.Remove); //egyből látszódik a változás a grid-ben, nem csak a callback lefutásakor! felhasználóbarátabb... - J.

            //SignalRClient.PostDataAsync(messageTag, dataItem, async response =>
            //{
            //    if (response.Status != SignalResponseStatus.Success || response.ResponseData == null)
            //    {
            //        RefreshDataSourceAsync().Forget();
            //        return;
            //    }

            //    _dataSource.UpdateCollection(response.ResponseData, trackingState == TrackingState.Remove);

            //    var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, response.ResponseData, trackingState);
            //    await OnDataItemChanged.InvokeAsync(changedEventArgs);

            //    InvokeAsync(StateHasChanged).Forget();
            //}).Forget();

            //transfer = await devAdminSignalClient.PostDataAsync(SignalRTags.UpdateTransferAsync, transfer);
        }


        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<Guid>.Id))
            {
                e.Column.Visible = AcDomain.IsDeveloperVersion;
                e.Column.ShowInColumnChooser = AcDomain.IsDeveloperVersion;
            }
        }

        protected override Task SetParametersAsyncCore(ParameterView parameters)
        {
            if (!IsFirstInitializeParameters)
            {
                base.DataItemDeleting = EventCallback.Factory.Create<GridDataItemDeletingEventArgs>(this, OnItemDeleting);
                base.EditModelSaving = EventCallback.Factory.Create<GridEditModelSavingEventArgs>(this, OnItemSaving);

                CustomizeElement += OnCustomizeElement;

                //ShowFilterRow = true;
                //PageSize = 4;
                //ShowGroupPanel = true;
                //AllowSort = false;

                TextWrapEnabled = false;

                //var dataColumns = GetDataColumns();

                //var idColumn = dataColumns.FirstOrDefault(x => x.FieldName == nameof(IId<Guid>.Id));
                //if (idColumn != null)
                //{
                //    idColumn.ShowInColumnChooser = AcDomain.IsDeveloperVersion;
                //    idColumn.Visible = !AcDomain.IsDeveloperVersion;
                //}

                IsFirstInitializeParameters = true;
            }

            return base.SetParametersAsyncCore(parameters);
        }


        protected override void OnParametersSet()
        {
            base.OnParametersSet();

            if (GridName.IsNullOrWhiteSpace()) GridName = $"{typeof(TDataItem).Name}Grid";

            _gridLogName = $"[{GridName}]";

        }
    }
}